iGent Concert - iGent Concert

Documentation for the Fabric protocol and the services that run the iGentAI agent platform

iGent Concert documents the current iGentAI platform: Fabric as the internal protocol spine, plus the services that implement inference, runtime orchestration, workspace state, configuration, observability, and client access.

The musical names still matter, but the old service-to-service story has changed. Fabric is the common language inside the system. Diminuendo exposes that language to first-party clients and hosts optional edge adapters for external protocols such as ACP, MCP, A2A, and AG-UI.

The Set

Area	Role	Runtime	Current job
Fabric	Protocol spine	TypeScript, Rust, Go, Python, Swift SDKs	Defines the canonical JSON-RPC methods, profiles, transports, identity model, and edge-adapter rules
Diminuendo	Client gateway	TypeScript on Bun	Authenticates users, serves the web/API surface, brokers sessions, and projects Fabric state to clients
Podium	Runtime authority	Rust	Deploys, starts, routes, and supervises agent processes through company-wide gateway and coordinator services
Ensemble	Inference authority	Go	Serves native inference APIs for model listing and generation over provider adapters
Unison	Configuration and resource authority	TypeScript on Bun	Stores tenant-scoped configuration and exposes Fabric resource/sync surfaces alongside REST and WebSocket compatibility routes
Chronicle	Workspace authority	Rust	Provides optional versioned workspaces, sync, and content-addressed storage for agent files

How To Read These Docs

Start with Fabric Overview if you need the system model. It explains which service owns which authority and how protocol profiles fit together.

Use the service sections when you need implementation details: ports, routes, deployment, configuration, and operational behavior. The service docs are intentionally concrete; if they conflict with an older ACP-native mental model, the Fabric pages win.

Current Shape

First-party clients
web | desktop | codex-tui
        |
        | Fabric JSON-RPC, WebSocket, REST, and app APIs
        v
Diminuendo
auth | sessions | projection | selective brokering
        |
        +--> Podium       staging runtime, agents, deployment registry
        +--> Ensemble     staging inference models and generation
        +--> Unison       config, resources, sync, Explorer
        +--> Chronicle    optional versioned workspace/sync authority

Optional edge adapters live beside the gateway:
ACP | MCP | A2A | AG-UI

Design Principles

Fabric first internally: first-party clients and services converge on Fabric profiles instead of treating ACP or another external protocol as the source of truth.
Clear authority boundaries: Podium owns runtime, Ensemble owns inference, Unison owns distributed configuration/resources, Chronicle owns versioned workspaces, and Diminuendo owns the client-facing gateway.
Adapters at the edge: ACP, MCP, A2A, and AG-UI are useful interoperability surfaces, but they are projections of Fabric semantics, not the internal architecture.
Local-first development, hosted core dependencies: the root Fabric workspace provides the trusted wrappers for running owned services locally while consuming company-wide staging Podium, Chronicle, and Ensemble by default.