Agent Mesh Platform — Overview¶

Target Architecture — Final-State Design

This page describes the final-state target architecture of the Agent Mesh Platform. It is the AI-native execution fabric of the ConnectSoft AI Software Factory — not a chatbot and not an assistant, but the autonomous workforce that produces, validates, and evolves software artifacts on behalf of every tenant and project.

The Agent Mesh is the platform that hosts and operates ConnectSoft's autonomous agents. Where the Control Plane decides what must happen and orchestrates workflows, the Agent Mesh is where the work is actually done: it claims agent tasks, loads governed context packages from the Knowledge Platform, executes skills on the Microsoft Agent Framework runtime, routes model calls, invokes tools, validates outputs, self-corrects, and emits every event in the canonical envelope.

Purpose¶

The Agent Mesh exists to make autonomous software production safe, reusable, observable, and traceable at multi-tenant scale. It provides a single, governed runtime in which any agent role is interchangeable, every execution is grounded in retrieved knowledge, and every artifact can be traced back to the task, agent, skill, model, and context that produced it.

Role in the Factory¶

flowchart LR
    Intent["Business Intent"] --> CP["Control Plane"]
    CP -->|"assigns AgentTask"| Mesh["Agent Mesh"]
    Mesh -->|"requests ContextPackage"| Knowledge["Knowledge Platform"]
    Knowledge -->|"grounded context"| Mesh
    Mesh -->|"model calls"| Integration["Integration Platform"]
    Mesh -->|"produces artifacts"| Templates["Template Library Platform"]
    Mesh -->|"emits events"| Observability["Observability & Feedback"]
    Mesh -->|"enforced by"| Governance["Governance, Security & Compliance"]

Hold "Alt" / "Option" to enable pan & zoom

The Control Plane assigns structured work; the Agent Mesh executes it. The mesh never invents context — it pulls it from Knowledge. It never bypasses policy — Governance gates registration, model routing, and tool access. It never hides outcomes — Observability receives the full event stream.

Core Responsibilities¶

Responsibility	Description
Agent hosting	Run agents on the Microsoft Agent Framework runtime via `ConnectSoft.Extensions.AI.AgentsFramework`, with managed lifecycle, pooling, and health.
Task processing	Claim, execute, validate, correct, and complete agent tasks against the task contract.
Context grounding	Request and consume context packages from the Knowledge Context Builder so every execution is knowledge-grounded.
Skill execution	Resolve and run versioned skills with explicit input/output contracts.
Model routing	Select and invoke the right model provider through the `ModelRouterService` and the Integration Platform.
Tool adaptation	Expose governed tools to agents over the Model Context Protocol (MCP).
Validation & correction	Validate every output against schema, naming, dependency, and policy rules; self-correct within bounded attempts.
Event emission	Emit lifecycle, domain, and integration events in the canonical envelope.
Observability	Capture telemetry, traces, and health for every model and tool invocation.

Key Capabilities¶

Autonomous workforce — eight agent clusters spanning the full delivery lifecycle, from vision to runtime evolution (see Agent Clusters).
Interchangeable agents — agents are defined, versioned, and permission-scoped in the Agent Registry, so any compatible agent can fulfil a role.
Reusable skills — capabilities are packaged as versioned skills in the Skill Registry and reused across agents and projects.
Grounded execution — every run consumes a governed context package, keeping the platform honest, current, and explainable.
Provider-agnostic models — Azure OpenAI, OpenAI, and Ollama are routed behind a single policy-driven router.
Bounded self-correction — failed validation triggers feedback-driven correction up to a contract-defined limit before human escalation.
End-to-end traceability — a single traceId links intent → task → execution → artifact → runtime feedback.

High-Level Component Diagram¶

flowchart TB
    subgraph Mesh["Agent Mesh Platform"]
        Runtime["Agent Runtime<br/>(Microsoft Agent Framework)"]
        AgentReg["Agent Registry"]
        SkillReg["Skill Registry"]
        Router["Model Router"]
        Tools["Tool Adapter Layer (MCP)"]
        Validation["Validation & Correction"]
        Telemetry["Agent Telemetry"]
        Pool["Agent Pool Manager"]
    end
    Runtime --> AgentReg
    Runtime --> SkillReg
    Runtime --> Router
    Runtime --> Tools
    Runtime --> Validation
    Runtime --> Telemetry
    Pool --> Runtime
    Router --> Integration["Integration Platform"]
    Runtime --> Knowledge["Knowledge Platform"]
    Validation --> Governance["Governance & Compliance"]

Hold "Alt" / "Option" to enable pan & zoom

Platform Building Blocks¶

The mesh is composed of eleven factory microservices in the ConnectSoft.Factory.AgentMesh.* namespace:

Service	Responsibility
`ConnectSoft.Factory.AgentMesh.AgentRuntimeService`	Hosts agents on the Microsoft Agent Framework; orchestrates a single execution.
`ConnectSoft.Factory.AgentMesh.AgentRegistryService`	Owns `AgentDefinition` / `AgentVersion`; registration, versioning, permission scoping.
`ConnectSoft.Factory.AgentMesh.SkillRegistryService`	Owns `SkillDefinition` / `SkillVersion`; skill contracts and discovery.
`ConnectSoft.Factory.AgentMesh.ModelRouterService`	Policy-driven model provider selection and invocation.
`ConnectSoft.Factory.AgentMesh.ToolAdapterService`	MCP tool adapters; governed tool exposure to agents.
`ConnectSoft.Factory.AgentMesh.AgentTaskService`	Owns `AgentTask`; task intake, claiming, and lifecycle.
`ConnectSoft.Factory.AgentMesh.AgentExecutionService`	Owns `AgentExecution` / `SkillExecution`; runs the execution pipeline.
`ConnectSoft.Factory.AgentMesh.AgentValidationService`	Owns `ValidationResult`; schema/naming/dependency/policy checks.
`ConnectSoft.Factory.AgentMesh.AgentCorrectionService`	Owns `CorrectionAttempt`; feedback-driven self-correction.
`ConnectSoft.Factory.AgentMesh.AgentTelemetryService`	Owns `ModelInvocation` / `ToolInvocation` telemetry and metrics.
`ConnectSoft.Factory.AgentMesh.AgentPoolManager`	Owns `AgentHealthStatus`; pooling, warm capacity, and health.

Integration with Other Platforms¶

Platform	Interaction
Control Plane	Assigns agent tasks and orchestrates multi-agent workflows; consumes mesh lifecycle events.
Knowledge Platform	Supplies governed context packages; receives artifacts and execution memory.
Integration Platform	Provides model provider connectivity (Azure OpenAI / OpenAI / Ollama) behind the model router.
Template Library Platform	Supplies templates skills use to scaffold and generate artifacts.
Governance, Security & Compliance	Authorizes agent registration, model policies, tool access, and tenant isolation.
Observability & Feedback	Consumes telemetry and events to attribute quality and close the improvement loop.

For the lifecycle of a single agent run, see Agent Execution Flow; for how agents cooperate, see Agent Collaboration Patterns; and for the full roster, see the Agent Catalog and Agent System Overview.

Final-State Summary¶

In its final state, the Agent Mesh is the autonomous workforce of the ConnectSoft AI Software Factory: a multi-tenant, policy-governed, fully observable runtime built on the Microsoft Agent Framework. Every agent is registered and versioned, every skill is reusable, every execution is grounded in retrieved knowledge, every output is validated and self-corrected, and every action is emitted as a traceable event. This is what allows the factory to scale autonomous software production without sacrificing governance, reusability, or trust.