Latest Forum Discussions

Agent Harness Core

2026-04-18T03:47:04.3100000

Please see our GitHub project here:

GitHub: https://github.com/OzzieAI-AU/AgentHarnessCore

https://www.youtube.com/watch?v=Xxuxg8PcBvc

The Architecture of Autonomy: Evolution of the C# Harness Engineering Framework

In the rapidly evolving landscape of artificial intelligence, the industry is witnessing a fundamental shift in how we conceptualize "Agents." For years, the focus remained squarely on the Large Language Model (LLM) itself—treating the model as the brain, the hands, and the voice of the system. However, as developers attempted to deploy these models into complex, production-grade environments, they encountered a "reliability ceiling." Raw LLMs, while brilliant, are inherently non-deterministic and prone to "hallucinations" or structural failures. This gave birth to the philosophy of Harness Engineering, a systematic approach to AI orchestration that moves the focus from the model to the surrounding "Operating System" that constrains and empowers it.

Defining the Harness: Beyond the Chat Interface

At its core, a Harness is a deterministic wrapper for a non-deterministic engine. In the OzzieAI.Agentica framework, we have built this using the robust, type-safe capabilities of C#. Unlike traditional Python-based agent frameworks that rely on "loose" scripts, a C# Harness treats the LLM as a modular component (the IProvider) that must answer to a set of strict, compiled validators known as Gates (IGates). This architecture mirrors the relationship between a CPU and an Operating System. The CPU provides raw compute power, but the OS manages memory, enforces security, and ensures that one process does not crash the entire machine. By building our Harness in C#, we leverage the power of ASP.NET Core, Dependency Injection, and Task-based parallelism to create agents that are not just conversational, but operational.

Harness Engineering recognizes that a model’s output is only useful if it meets specific criteria. For instance, if an agent is tasked with writing a SQL query, the Harness does not simply take the string output and attempt to execute it. Instead, the Harness passes that output through a SQLGate. This gate performs a syntax check and a schema-validation check. If the gate rejects the output, the Harness initiates a self-correction loop. It feeds the compiler error back to the model, providing it with the "state" of its failure. This iterative process continues until the gate is satisfied, ensuring that the "Worker" only submits verified results to the "Manager."

The A2AP Protocol: Creating a Universal Language for Swarms

While a single Harness ensures individual agent reliability, complex problems require a collective effort. This necessitates a communication standard, which we have implemented as the Agent 2 Agent Protocol (A2AP). A2AP is the connective tissue that allows disparate agents—potentially running on different servers or subdomains—to collaborate with surgical precision. By using a typed message-passing system, we eliminate the ambiguity of natural language coordination. Every message in an A2AP swarm is a contract, defined by a MessageType, a SwarmId, and a CorrelationId.

Stateful Orchestration: The Heart of the Swarm

One of the most significant innovations in the OzzieAI.Agentica framework is the implementation of "Stateful" agents. In traditional AI interactions, the session is ephemeral; if the connection is lost, the context is destroyed. In our Stateful A2AP implementation, the "State" is a living, serializable object. The SwarmState serves as a persistent ledger of every task, every dependency, and every result achieved within a mission. This allows for "Hydration"—the ability for a Manager Agent to shut down to save resources and later "wake up," reload its SwarmState from a database, and resume exactly where it left off.

In this context, statefulness is what transforms an agent from a chatbot into a digital employee. A stateful manager understands that Task B cannot begin until Task A has reached the "Completed" status. It tracks the health of its workers and can re-assign tasks if a specific node fails. This level of oversight is only possible because the protocol mandates that every worker report its progress via ProgressUpdateMessages. These updates are not just for show; they provide the metrics—tokens used, time elapsed, and current iterations—that the Manager uses to make real-time strategic decisions about the swarm’s deployment.

The Boss-Manager-Worker Hierarchy

To manage the complexity of large-scale tasks, the framework utilizes a structured hierarchy generated by a "Boss Agent." The Boss is the high-level architect. When a mission is received, the Boss does not execute code; instead, it uses the A2AP.GetDeployPrompt logic to design a SwarmDeploymentPlan. This plan identifies the optimal Manager persona and the specialized Workers required for the job. This separation of concerns is vital. The Boss focuses on strategy, the Manager focuses on logistics and state tracking, and the Workers focus on execution within their specific Harnesses.

The Mechanical Necessity of the Agent Card

For a swarm to be truly dynamic, agents must be discoverable. This is achieved through the AgentCard, a standard JSON manifest published by every agent service. The AgentCard acts as a "Resume" or "Interface Definition." It tells the swarm what skills the agent possesses, what technical interfaces it supports (REST, SignalR), and critically, its capabilities regarding state and persistence. When a Manager needs a worker with "File Management" skills, it doesn't need to guess; it queries the local network for AgentCards that match the required skill ID. This creates a "Plug-and-Play" ecosystem where agents can be swapped out or upgraded without breaking the overall protocol logic.

Harness Engineering as a Science

Ultimately, the OzzieAI.Agentica framework is built on the belief that AI development must move away from "vibes" and toward "engineering." By constraining LLMs with C# gates, orchestrating them with the A2AP protocol, and maintaining mission state in a persistent ledger, we provide a path toward truly autonomous systems. We are building frameworks where the agent is not just a tool for the user, but a collaborator that can manage its own failures, report its own progress, and achieve complex goals through systematic coordination.

The future of AI is not a single, giant model. It is a swarm of highly specialized, highly reliable, and deeply stateful agents, all working within a Harness that ensures they never overstep their bounds. Through this framework, we have laid the foundation for an "Agentic Operating System" that is ready for the demands of the modern enterprise, the scalability of the web, and the unpredictable nature of real-world missions.

Agent to Agent Protocol - A2AP

2026-04-15T07:23:08.0270000

Agent 2 Agent Protocol (A2AP) – Full Technical Report

Version: 1.0 (Production-ready implementation)

Purpose: Structured, reliable, observable, and hierarchical communication between autonomous AI agents in a dynamic swarm.

GitHub: https://github.com/OzzieAI-AU/A2AP

1. What is A2AP?

A2AP is a message-based protocol specifically designed for agent-to-agent coordination.

It goes far beyond simple chat-style messaging by enforcing:

Typed messages with clear semantics
Task planning, assignment, tracking, and finalization
Hierarchical roles (Boss → Manager → Workers)
Full auditability and state tracking via SwarmState
Quality gates and revision loops
Clean completion signaling

It is the nervous system of the OzzieAI Agentica swarm.

2. Core Design Principles

Everything is a typed message — no raw strings between agents.
Manager owns the truth — The Manager maintains the live SwarmState.
Boss only receives final results — It does not micro-manage.
Workers are specialists — They execute one focused task at a time.
Completion is explicit — Not guessed via timeouts or counters alone.
Fully JSON-serializable — Easy to persist, log, or send over any transport.

3. Key Data Structures

SwarmDeploymentPlan

The blueprint generated by the Boss LLM. It defines:

Manager name and directive
List of Workers with their worker_name, system_prompt, tools, and collaborators
Swarm-wide metadata (swarm_id, original_task, timeout, etc.)

Agent Roles

Boss — Strategic orchestrator. Generates the deployment plan and receives the final report.
Manager — Tactical coordinator. Breaks down work, assigns tasks, reviews quality, and decides when the mission is complete.
Worker — Leaf-level executor. Performs the actual reasoning and tool usage.

4. Message Types (The Heart of A2AP)

All communication happens through these strongly-typed messages:

Message Type Direction Purpose SwarmDeployment Boss → Manager Sends the full SwarmDeploymentPlan to start the mission TaskAssignment Manager → Worker (or sub-manager) Assigns one or more TaskDefinitions ResultSubmission Worker → Manager → Boss Submits final output of a task after quality gate ProgressUpdate Any → Manager Real-time progress (optional, not heavily used yet) FinalReport Manager → Boss Official mission complete signal — contains all results Error Any → Manager/Boss Reports failures for graceful handling

All messages inherit from A2APMessage (with message_id, timestamp, sender_agent, recipient_agent, swarm_id, correlation_id).

5. How A2AP Execution Flow Works (Step by Step)

User gives mission to Boss
Boss receives high-level natural language task.
Boss generates SwarmDeploymentPlan
Uses LLM to intelligently design Manager name + list of specialized Workers. Creates unique swarm_id.
Boss sends SwarmDeploymentMessage to Manager
This is the official hand-off. The swarm now begins.
Manager receives SwarmDeployment
Parses the plan. Creates TaskDefinition for each Worker (injects full context). Sends TaskAssignmentMessage to each Worker (matched by name).
Each Worker executes
Receives TaskAssignmentMessage. Runs Think → Act (tools) → Observe cycle. Aggregates outputs. Sends ResultSubmissionMessage back to Manager.
Manager reviews every result
Runs quality gate. If approved → forwards to Boss. If rejected → sends revision. Updates SwarmState.
Manager declares completion
When all tasks have status Completed, Manager sends FinalReportMessage to Boss.
Boss receives FinalReport
Triggers professional HTML report generation. Mission officially ends.

6. SwarmState & Tracking

The ManagerAgent maintains a live SwarmState object that contains:

swarm_id
List of all TaskDefinitions with current status
Overall status
Timestamps and metrics

This is the single source of truth for “are we done yet?”

7. Completion Logic (How Boss Knows Everything is Finalised)

The Manager is responsible for deciding completion. Once all tasks are Completed, the Manager sends one FinalReportMessage. The Boss reacts to the FinalReportMessage. This makes the protocol robust and observable.

8. Error Handling

Any agent can send an ErrorMessage. The Manager forwards critical errors to the Boss. Workers that fail repeatedly after revisions are flagged.

9. Why A2AP is Powerful

Clear separation of concerns: Boss = strategy, Manager = coordination, Worker = execution.
Quality control built-in: Manager acts as a strict reviewer.
Full traceability: Every task has ID, status, result, and audit trail.
Extensible: Easy to add new message types or peer-to-peer collaboration.
Transport agnostic: Currently uses in-memory AgentBus, but can run over any transport.

10. Current Implementation Status

Full message types and serialization implemented.
Boss → Manager → Worker hierarchy working.
Dynamic swarm generation via LLM working.
Task distribution by name working.
Quality gate + revision loop active.
FinalReport signaling working.
Professional HTML report generation at end.

Remaining areas for future enhancement:

More sophisticated dependency graphs between tasks.
Real-time ProgressUpdateMessage dashboard.
Peer-to-peer worker collaboration when permitted.
Persistent swarm state across restarts.

Code:

    using System;
    using System.Collections.Generic;
    using System.Text.Json.Serialization;


    /// <summary>
    /// Defines the type of message exchanged between agents in the Agent 2 Agent Protocol (A2AP).
    /// Every communication in the protocol is typed to enforce clear workflows for deployment, planning,
    /// tracking, and finalization of swarm-based tasks.
    /// </summary>
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public enum MessageType
    {
        /// <summary>
        /// Initiates a complete swarm deployment from the Boss agent.
        /// </summary>
        SwarmDeployment,

        /// <summary>
        /// Assigns one or more tasks from the Manager to Workers (or sub-managers).
        /// </summary>
        TaskAssignment,

        /// <summary>
        /// Reports real-time progress and status updates from any agent.
        /// </summary>
        ProgressUpdate,

        /// <summary>
        /// Submits the final result of a completed task.
        /// </summary>
        ResultSubmission,

        /// <summary>
        /// Delivers the aggregated final report of an entire swarm mission.
        /// </summary>
        FinalReport,

        /// <summary>
        /// Reports an error or failure condition that requires attention.
        /// </summary>
        Error
    }

    /// <summary>
    /// Defines the execution status of any task or subtask within an A2AP swarm.
    /// Used consistently across planning, tracking, and finalization phases.
    /// </summary>
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public enum TaskStatus
    {
        /// <summary>
        /// Task has been created but not yet started.
        /// </summary>
        Pending,

        /// <summary>
        /// Task is actively being executed.
        /// </summary>
        InProgress,

        /// <summary>
        /// Task completed successfully.
        /// </summary>
        Completed,

        /// <summary>
        /// Task failed and cannot continue without intervention.
        /// </summary>
        Failed,

        /// <summary>
        /// Task was explicitly cancelled by the Manager or Boss.
        /// </summary>
        Cancelled
    }

    /// <summary>
    /// Defines the hierarchical role an agent plays within a specific A2AP swarm deployment.
    /// </summary>
    [JsonConverter(typeof(JsonStringEnumConverter))]
    public enum AgentRole
    {
        /// <summary>
        /// Top-level orchestrator that generates the SwarmDeploymentPlan.
        /// </summary>
        Boss,

        /// <summary>
        /// Mid-level coordinator that receives the deployment plan, breaks down tasks,
        /// assigns work to Workers, tracks progress, and produces the final report.
        /// </summary>
        Manager,

        /// <summary>
        /// Leaf-level specialist that executes assigned subtasks using its dedicated system prompt.
        /// </summary>
        Worker
    }

    /// <summary>
    /// Abstract base class for every message in the Agent 2 Agent Protocol (A2AP).
    /// Provides standardized routing, correlation, and auditing fields so that any transport
    /// (HTTP, message queues, WebSockets, etc.) can reliably deliver and track communications.
    /// All concrete message types inherit from this class and set their specific MessageType.
    /// </summary>
    public abstract class A2APMessage
    {
        /// <summary>
        /// Globally unique identifier for this individual message (GUID string).
        /// </summary>
        [JsonPropertyName("message_id")]
        public string MessageId { get; set; } = Guid.NewGuid().ToString();

        /// <summary>
        /// UTC timestamp when the message was created by the sender.
        /// </summary>
        [JsonPropertyName("timestamp")]
        public DateTime Timestamp { get; set; } = DateTime.UtcNow;

        /// <summary>
        /// Name or identifier of the agent that sent this message.
        /// </summary>
        [JsonPropertyName("sender_agent")]
        public string SenderAgent { get; set; } = string.Empty;

        /// <summary>
        /// Name or identifier of the intended recipient agent.
        /// Use "*" to indicate a broadcast within the swarm.
        /// </summary>
        [JsonPropertyName("recipient_agent")]
        public string RecipientAgent { get; set; } = string.Empty;

        /// <summary>
        /// The A2AP message type that determines how the recipient should process the payload.
        /// </summary>
        [JsonPropertyName("message_type")]
        public MessageType MessageType { get; set; }

        /// <summary>
        /// Correlation identifier that links related messages (e.g., a task assignment with its
        /// subsequent progress updates and final result). Usually set to the SwarmId or a task-specific ID.
        /// </summary>
        [JsonPropertyName("correlation_id")]
        public string CorrelationId { get; set; } = string.Empty;

        /// <summary>
        /// Unique identifier of the swarm deployment session to which this message belongs.
        /// All agents participating in the same mission share this ID for context.
        /// </summary>
        [JsonPropertyName("swarm_id")]
        public string SwarmId { get; set; } = string.Empty;
    }

    /// <summary>
    /// Represents the complete dynamic swarm hierarchy generated by the Boss LLM.
    /// This is the foundational data structure of A2AP and is embedded inside a SwarmDeploymentMessage.
    /// The Manager uses this plan to instantiate itself and all required Worker agents.
    /// </summary>
    public class SwarmDeploymentPlan
    {
        /// <summary>
        /// The name of the Manager agent that will orchestrate the entire swarm.
        /// </summary>
        [JsonPropertyName("manager_name")]
        public string ManagerName { get; set; } = string.Empty;

        /// <summary>
        /// The high-level directive provided to the Manager describing the overall mission goals,
        /// success criteria, and coordination strategy.
        /// </summary>
        [JsonPropertyName("manager_directive")]
        public string ManagerDirective { get; set; } = string.Empty;

        /// <summary>
        /// The ordered list of specialized Worker agents that the Manager will instantiate and assign subtasks to.
        /// Each Worker is purpose-built for a specific aspect of the mission.
        /// </summary>
        [JsonPropertyName("workers")]
        public List<WorkerDeploymentPlan> Workers { get; set; } = new();

        /// <summary>
        /// The original natural-language task description that the Boss received and used to generate this plan.
        /// Retained for full auditability and context.
        /// </summary>
        [JsonPropertyName("original_task")]
        public string OriginalTask { get; set; } = string.Empty;

        /// <summary>
        /// Unique identifier for the entire swarm deployment session. Generated once by the Boss
        /// and propagated to every message and agent involved in the mission.
        /// </summary>
        [JsonPropertyName("swarm_id")]
        public string SwarmId { get; set; } = string.Empty;

        /// <summary>
        /// Optional maximum allowed execution time (in minutes) for the entire swarm.
        /// The Manager may enforce this timeout during tracking.
        /// </summary>
        [JsonPropertyName("max_execution_minutes")]
        public int MaxExecutionMinutes { get; set; } = 60;
    }

    /// <summary>
    /// Represents a single specialized Worker agent that the Manager will dynamically instantiate.
    /// Each Worker receives its own tailored system prompt and tool set.
    /// </summary>
    public class WorkerDeploymentPlan
    {
        /// <summary>
        /// Unique name of this Worker within the swarm (must be unique across all Workers).
        /// </summary>
        [JsonPropertyName("worker_name")]
        public string WorkerName { get; set; } = string.Empty;

        /// <summary>
        /// Complete system prompt that defines the Worker's persona, expertise, constraints,
        /// output format requirements, and any safety or reasoning guidelines.
        /// This prompt is used verbatim when spinning up the Worker LLM instance.
        /// </summary>
        [JsonPropertyName("system_prompt")]
        public string SystemPrompt { get; set; } = string.Empty;

        /// <summary>
        /// List of tool names (or capability identifiers) that this Worker is permitted to invoke.
        /// Examples: "web_search", "code_execution", "image_analysis", etc.
        /// The hosting runtime interprets these strings to grant the appropriate tools.
        /// </summary>
        [JsonPropertyName("tools")]
        public List<string> Tools { get; set; } = new();

        /// <summary>
        /// Optional list of other Worker names that this Worker may collaborate with directly.
        /// Enables peer-to-peer communication within the swarm when the Manager permits it.
        /// </summary>
        [JsonPropertyName("collaborators")]
        public List<string> Collaborators { get; set; } = new();
    }

    /// <summary>
    /// Message sent by the Boss agent to the designated Manager to deploy an entire swarm.
    /// Contains the full SwarmDeploymentPlan that the Manager must execute.
    /// This is the entry point of every A2AP mission.
    /// </summary>
    public class SwarmDeploymentMessage : A2APMessage
    {
        /// <summary>
        /// The complete swarm deployment plan generated by the Boss.
        /// </summary>
        [JsonPropertyName("deployment_plan")]
        public SwarmDeploymentPlan DeploymentPlan { get; set; } = new();

        /// <summary>
        /// Initializes a new SwarmDeploymentMessage with the correct message type.
        /// </summary>
        public SwarmDeploymentMessage()
        {
            MessageType = MessageType.SwarmDeployment;
        }
    }

    /// <summary>
    /// Defines a single atomic task or subtask that participates in the swarm's overall mission.
    /// Used during planning (by the Manager) and tracking (by all agents).
    /// </summary>
    public class TaskDefinition
    {
        /// <summary>
        /// Unique identifier for this task within the swarm (usually a short GUID or incremental ID).
        /// </summary>
        [JsonPropertyName("task_id")]
        public string TaskId { get; set; } = string.Empty;

        /// <summary>
        /// Human-readable title that summarizes the task's purpose.
        /// </summary>
        [JsonPropertyName("title")]
        public string Title { get; set; } = string.Empty;

        /// <summary>
        /// Detailed description and exact instructions that the assigned agent must follow.
        /// </summary>
        [JsonPropertyName("description")]
        public string Description { get; set; } = string.Empty;

        /// <summary>
        /// Name of the agent (Worker or sub-Manager) responsible for executing this task.
        /// </summary>
        [JsonPropertyName("assigned_to")]
        public string AssignedTo { get; set; } = string.Empty;

        /// <summary>
        /// Current execution status of the task.
        /// </summary>
        [JsonPropertyName("status")]
        public TaskStatus Status { get; set; } = TaskStatus.Pending;

        /// <summary>
        /// List of TaskIds that must be Completed before this task may begin.
        /// Enables dependency-driven planning and execution ordering.
        /// </summary>
        [JsonPropertyName("dependencies")]
        public List<string> Dependencies { get; set; } = new();

        /// <summary>
        /// Priority level (higher number = higher priority). Used by the Manager for scheduling.
        /// </summary>
        [JsonPropertyName("priority")]
        public int Priority { get; set; } = 1;

        /// <summary>
        /// Optional estimated completion time in minutes.
        /// </summary>
        [JsonPropertyName("estimated_minutes")]
        public int EstimatedMinutes { get; set; } = 0;
    }

    /// <summary>
    /// Message sent by the Manager to one or more Workers (or sub-managers) to assign tasks.
    /// This message drives the planning and delegation phase of A2AP.
    /// </summary>
    public class TaskAssignmentMessage : A2APMessage
    {
        /// <summary>
        /// The complete list of tasks being assigned in this batch.
        /// </summary>
        [JsonPropertyName("tasks")]
        public List<TaskDefinition> Tasks { get; set; } = new();

        /// <summary>
        /// Initializes a new TaskAssignmentMessage with the correct message type.
        /// </summary>
        public TaskAssignmentMessage()
        {
            MessageType = MessageType.TaskAssignment;
        }
    }

    /// <summary>
    /// Message sent periodically or on significant events by Workers (or the Manager) to report progress.
    /// Enables continuous tracking and allows the Manager to intervene if necessary.
    /// </summary>
    public class ProgressUpdateMessage : A2APMessage
    {
        /// <summary>
        /// The TaskId this progress update refers to.
        /// </summary>
        [JsonPropertyName("task_id")]
        public string TaskId { get; set; } = string.Empty;

        /// <summary>
        /// Latest known status of the referenced task.
        /// </summary>
        [JsonPropertyName("status")]
        public TaskStatus Status { get; set; }

        /// <summary>
        /// Numeric progress percentage (0-100).
        /// </summary>
        [JsonPropertyName("progress_percentage")]
        public int ProgressPercentage { get; set; }

        /// <summary>
        /// Free-form textual description of what has been accomplished and any blockers encountered.
        /// </summary>
        [JsonPropertyName("progress_description")]
        public string ProgressDescription { get; set; } = string.Empty;

        /// <summary>
        /// Arbitrary key-value metrics collected during execution (e.g., "tokens_used": "1243", "iterations": "7").
        /// </summary>
        [JsonPropertyName("metrics")]
        public Dictionary<string, string> Metrics { get; set; } = new();

        /// <summary>
        /// Initializes a new ProgressUpdateMessage with the correct message type.
        /// </summary>
        public ProgressUpdateMessage()
        {
            MessageType = MessageType.ProgressUpdate;
        }
    }

    /// <summary>
    /// Message sent by a Worker (or sub-manager) to the Manager when a task reaches completion.
    /// Contains the final output and any supporting artifacts.
    /// </summary>
    public class ResultSubmissionMessage : A2APMessage
    {
        /// <summary>
        /// The TaskId of the completed task.
        /// </summary>
        [JsonPropertyName("task_id")]
        public string TaskId { get; set; } = string.Empty;

        /// <summary>
        /// Primary textual result or answer produced by the task.
        /// </summary>
        [JsonPropertyName("result")]
        public string Result { get; set; } = string.Empty;

        /// <summary>
        /// Optional structured data payload (JSON-serializable dictionary) for machine-readable results.
        /// </summary>
        [JsonPropertyName("structured_data")]
        public Dictionary<string, object> StructuredData { get; set; } = new();

        /// <summary>
        /// List of artifact references (e.g., file paths, URLs, or base64-encoded data) produced by the task.
        /// </summary>
        [JsonPropertyName("artifacts")]
        public List<string> Artifacts { get; set; } = new();

        /// <summary>
        /// Final status of the task upon submission (normally Completed, but may be Failed).
        /// </summary>
        [JsonPropertyName("final_status")]
        public TaskStatus FinalStatus { get; set; } = TaskStatus.Completed;

        /// <summary>
        /// Initializes a new ResultSubmissionMessage with the correct message type.
        /// </summary>
        public ResultSubmissionMessage()
        {
            MessageType = MessageType.ResultSubmission;
        }
    }

    /// <summary>
    /// Final message sent by the Manager to the Boss once every task has been completed or the swarm
    /// has reached a terminal state. This message finalizes the entire mission and provides a consolidated outcome.
    /// </summary>
    public class FinalReportMessage : A2APMessage
    {
        /// <summary>
        /// High-level textual summary of the entire swarm mission outcome.
        /// </summary>
        [JsonPropertyName("summary")]
        public string Summary { get; set; } = string.Empty;

        /// <summary>
        /// Complete list of every task definition together with its final result and status.
        /// </summary>
        [JsonPropertyName("task_results")]
        public List<TaskDefinition> TaskResults { get; set; } = new();

        /// <summary>
        /// Overall success status of the entire swarm (Completed if all critical tasks succeeded).
        /// </summary>
        [JsonPropertyName("overall_status")]
        public TaskStatus OverallStatus { get; set; }

        /// <summary>
        /// Any strategic insights, recommendations, or suggested follow-up actions produced by the Manager.
        /// </summary>
        [JsonPropertyName("insights")]
        public string Insights { get; set; } = string.Empty;

        /// <summary>
        /// Swarm-wide performance metrics (e.g., total_tokens, total_duration_seconds, cost_estimate).
        /// </summary>
        [JsonPropertyName("metrics")]
        public Dictionary<string, string> Metrics { get; set; } = new();

        /// <summary>
        /// Initializes a new FinalReportMessage with the correct message type.
        /// </summary>
        public FinalReportMessage()
        {
            MessageType = MessageType.FinalReport;
        }
    }

    /// <summary>
    /// Message used by any agent to report errors, exceptions, or unexpected conditions.
    /// Enables graceful failure handling, retries, or escalation within the A2AP swarm.
    /// </summary>
    public class Error : A2APMessage
    {
        /// <summary>
        /// Short error code or category (e.g., "TOOL_FAILURE", "PROMPT_REJECTION", "TIMEOUT").
        /// </summary>
        [JsonPropertyName("error_code")]
        public string ErrorCode { get; set; } = string.Empty;

        /// <summary>
        /// Human-readable description of the error.
        /// </summary>
        [JsonPropertyName("error_message")]
        public string ErrorMessage { get; set; } = string.Empty;

        /// <summary>
        /// Detailed diagnostic information (stack trace, inner exception, or context).
        /// </summary>
        [JsonPropertyName("details")]
        public string Details { get; set; } = string.Empty;

        /// <summary>
        /// TaskId of the affected task, if the error is scoped to a specific task.
        /// </summary>
        [JsonPropertyName("affected_task_id")]
        public string AffectedTaskId { get; set; } = string.Empty;

        /// <summary>
        /// Initializes a new ErrorMessage with the correct message type.
        /// </summary>
        public Error()
        {
            MessageType = MessageType.Error;
        }
    }

    /// <summary>
    /// Maintainable in-memory (or persisted) representation of the entire swarm's current state.
    /// The Manager typically owns this object and updates it in response to incoming ProgressUpdateMessage
    /// and ResultSubmissionMessage instances. It is used for real-time tracking and can be serialized
    /// for persistence or dashboard visualization.
    /// </summary>
    public class SwarmState
    {
        /// <summary>
        /// The unique swarm identifier shared by all agents.
        /// </summary>
        [JsonPropertyName("swarm_id")]
        public string SwarmId { get; set; } = string.Empty;

        /// <summary>
        /// The original high-level task description that started the swarm.
        /// </summary>
        [JsonPropertyName("original_task")]
        public string OriginalTask { get; set; } = string.Empty;

        /// <summary>
        /// Current overall status of the entire swarm mission.
        /// </summary>
        [JsonPropertyName("overall_status")]
        public TaskStatus OverallStatus { get; set; } = TaskStatus.Pending;

        /// <summary>
        /// Mapping of Worker name → its current TaskStatus (for quick health overview).
        /// </summary>
        [JsonPropertyName("worker_statuses")]
        public Dictionary<string, TaskStatus> WorkerStatuses { get; set; } = new();

        /// <summary>
        /// Complete list of all tasks in the swarm, including their definitions, current status, and results.
        /// </summary>
        [JsonPropertyName("tasks")]
        public List<TaskDefinition> Tasks { get; set; } = new();

        /// <summary>
        /// UTC timestamp when the swarm was first deployed.
        /// </summary>
        [JsonPropertyName("deployment_time")]
        public DateTime DeploymentTime { get; set; } = DateTime.UtcNow;

        /// <summary>
        /// UTC timestamp of the most recent message or status change.
        /// </summary>
        [JsonPropertyName("last_activity")]
        public DateTime LastActivity { get; set; } = DateTime.UtcNow;

        /// <summary>
        /// Total elapsed time in seconds since deployment (computed on demand).
        /// </summary>
        [JsonIgnore]
        public double ElapsedSeconds => (DateTime.UtcNow - DeploymentTime).TotalSeconds;
    }

Summary

A2AP turns a loose collection of LLM agents into a disciplined, hierarchical, auditable swarm.

It works like this:

Boss designs the team → Manager assigns work and enforces quality → Workers execute → Manager verifies everything → Manager tells Boss “mission complete” → Boss delivers final report.

This protocol allows the OzzieAI Agentica framework to reliably tackle complex missions — including heavy binary model analysis — in a structured and observable way.

Agentica - OzzieAI's solution to Agents

2026-04-07T22:52:50.6230000

Hello Everyone,

Today, Agents running AI in smart ways, is very powerful! We have been working on Agentica for some time, correcting, perfecting, and getting it to that stage, where it can easily compete with other world leading Agent Swarms like AgentZero, Open Claw and others!

Download and evaluate Agentica today: https://github.com/OzzieAI-AU/Agentica

How Agentica works:

OzzieAI Agentica: Architectural Overview

OzzieAI Agentica is a biological analog for artificial intelligence, functioning as a digital organism with a nervous system (the Bus), a brain (the LLM), hands (Tools), and a multi-layered memory system (DragonMemory & LiveCache)[cite: 1]. It is designed as a hierarchical swarm where independent "brains" function as a unified entity[cite: 17].

I. The Macro-Architecture (The "Unison" Swarm)

Agentica is structured as a hierarchical swarm rather than a single chatbot[cite: 2, 3]. This "Unison" protocol utilizes a clear chain of command:

The Hierarchy

* The Boss: Provides the vision and high-dimensional reasoning for strategic planning[cite: 3, 42].

* The Manager: Provides tactics and project analysis[cite: 3, 45].

* The Worker: Executes specific tasks, such as code generation and terminal actions[cite: 3, 43, 45].

Each agent is an independent entity with its own dedicated LLM Provider and specific toolset[cite: 4]. This decoupled design ensures that if one agent fails a safety check, the rest of the system remains responsive[cite: 22].

II. The Internal Agent Loop (Cognition & Action)

Every agent operates on a recursive "Think-Act-Observe" cycle known as the "Digital Life Cycle"[cite: 5, 23]. Unlike standard chatbots that run once and stop, Agentica agents run a continuous, non-blocking loop[cite: 24]:

1. Ingestion: The agent receives a message via the AgentBus[cite: 24, 64].

2. Deliberation: The agent sends its memory and tool definitions to its LLM provider[cite: 25, 65].

3. Action: The agent executes tools (its "Hands"), such as terminal commands or file edits[cite: 26, 67].

4. Observation: Tool results are fed back into memory, and the agent "Self-Corrects" if errors are detected[cite: 27, 68].

III. The DragonMemory Engine

Knowledge in Agentica is categorized based on its "Half-Life" and utility through a three-tier persistence strategy[cite: 47, 48]:

1. Ephemeral Memory (RAM)

This is the active conversation history and immediate "train of thought" passed to the LLM during inference[cite: 28, 49].

2. Tactical Memory (The Skill Store)

This stores synthesized knowledge and specialized "How-To" skills discovered during tasks, such as specific compiler flags[cite: 29, 77].

3. Persistent Cache (LiveCache/Disk)

Data is serialized into a JSON format on the hard drive[cite: 30, 88]. This allows the system to retain context after a reboot[cite: 31].

IV. Knowledge Propagation (The "Bubble Up" Protocol)

A core innovation of the framework is how it learns across the hierarchy[cite: 11]. When a Worker discovers a technical solution (a "Skill"), it is not trapped at that level[cite: 12].

Using the "Bubble Up" protocol, the knowledge is automatically pushed up to the Manager and then the Boss[cite: 13, 34]. This ensures the entire organization stays synchronized; the Boss "knows" what technical discoveries were made without ever executing the tools personally[cite: 13, 35].

V. Security and the Human-in-the-Loop

Because agents have access to destructive tools like the Terminal, the framework implements a "Safety Gate"[cite: 36, 70].

The ApprovalTool acts as a circuit breaker[cite: 37, 70]. For destructive actions or code writes, the agent must pause its autonomous loop and wait for a manual "Y/N" from a human user before proceeding[cite: 38].

VI. The Scoring System and Continuity

Agentica uses a Scoring System (0-100) to track the "perfection" of persisted knowledge[cite: 54, 99]. A skill discovered by a Worker might start at a lower score, but if it successfully passes a code safety check or a build, the score is upgraded[cite: 100].

This metadata allows the system to prioritize high-confidence knowledge during future boots, ensuring the "Agent of Tomorrow" is always smarter than the "Agent of Yesterday"[cite: 101, 102].

XAI .NET Client - A Client for Grok

2026-04-05T21:40:48.2330000

Hello Everyone,

Today I am publishing a simple .NET Client for XAI's Grok: https://github.com/OzzieAI-AU/XAI-.NET-Client

As of today, this is a complete client, and supports full multimodal responses.

This Client is simple and light weight.

Have fun and let us know your thoughts!

All the best,

Chris

Orbital Mechanics - A Simple .NET Library

2026-04-04T02:48:34.7030000

Hello Everyone,

Coming Soon

N-Dof Kinematics - .NET Robotics Engine

2026-04-04T02:46:32.3100000

Hello Everyone,

Coming soon...

ArborNet - World Class Machine Learning Library

2026-04-04T00:52:12.4970000

Hello Everyone,

Today I am announcing the release of Ozzie AI's new baby, a .NET 10, Machine Learning Library, that aims to become a world class library for Machine Learning.

Please check out ArborNet on GitHub: https://github.com/OzzieAI-AU/ArborNet

Although in early stages of development, and no doubt containing a few bugs still, but I am sure, together, being that it is Open Source, we can keep making it better and better.

We are integrating Holonomic AI Research, it is in very early stages, but its a start.

This Forum, and OzzieAI aims to advance the standard, of Open Source AI and what you, the end user can build advanced machine learning networks quickly and easily.

The .NET Ecosystem has been famously left in the dust when it comes to Machine Learning! In recent releases, the .NET Ecosystem has become much faster, and a little more Machine Learning Friendly. After years of small attempts at C# and AI and some difficulty learning some of the other Libraries that exist, I decided to take a leap and build what I feel is one of the better and easier to use, libraries.

All the best,

Chris