SYSTEM SURFACES
One governed system, several focused surfaces.
Control plane
aio-server owns workflows, tasks, run transitions, and reconciliation against desired state. It does not hide run state in a separate application database.
Workers + sidecars
aio-worker dispatches agent execution while the sidecar defines the local run boundary. cli and docker profiles have different containment grades.
Reflex + agentgateway
Typed policy decisions sit before dispatch; the declared tool plane is enforced at the wire for gateway-routed calls.
CLI + operator console
Operators inspect runs, held steps, and tasks through an attention-first surface. The same decisions remain available through aioctl.
GITOPS
The registry is the fleet’s desired state.
Agent manifests, workflow definitions, providers, and MCP grants are versioned together. Review happens in the forge; reconciliation compares the desired registry with the served fleet and names drift.
- Reviewed change: a grant is a diff, not an invisible console toggle.
- Boot-time convergence: available today; event-triggered convergence remains in progress.
- Declared tools: only allowlisted MCP servers can be granted to gateway-routed runs.
- Versioned execution: a run retains the definition identity needed for replay.
The open-source tree names no preferred forge vendor. Forge integration is a boundary, not a requirement to replace your existing source-control workflow.
TASK PLANE
Forge work enters without becoming a blind dispatch.
Forge ingestion can adopt or fold issue-backed work into governed task rows. Ingestion itself never dispatches an agent. A task still needs valid acceptance, an explicit start path, and the normal policy decisions.
A forge-ingested row with empty acceptance is refused with acceptance_required rather than being allowed to fold to done on any terminal run. Console task actions are forge-bind aware so the interface does not offer operations the server will refuse.
Still in progress: lifecycle write-back to forge issues and complete acceptance enforcement across every ingested path.
AGENTS + A2A
Agents remain actors, not sources of authority.
Agent manifests name the runtime, goal, tools, and environment. A2A communication lets actors exchange work while the control plane remains the owner of orchestration and evidence.
Ad-hoc A2A sends become single-turn runs, but their reflex gate defaults to none today. They must not be exposed to untrusted callers as though they carried the same admission policy as a fully gated workflow.
The wired, CI-qualified harness is Claude Code. Codex, Kimi, and Gemma harnesses are planned, not silently implied by the word “agent.”
OBSERVABILITY
The console is a view. The log is the truth.
The operator surface leads with attention: held steps, runs that need input, and task state. Run detail is organized around steps because that is where decisions happen.
| Surface | Operator question |
|---|---|
| Dashboard | What needs a human now? |
| Run detail | Which step held, completed, retried, or failed? |
| Event record | What exact ordered transitions produced this state? |
| CLI replay | Can the run be re-verified against its definition? |
| Metrics | What is the health of the supporting services? |
/metrics remains plaintext in the current profiles. The event log provides governance evidence; it does not replace conventional infrastructure monitoring.
KNOWLEDGE + EXTENSION
Compose new capability without inventing hidden authority.
The platform direction includes a knowledge plane, declared ingress sources, and business-application overlays. The rule stays the same: external events may trigger governed runs, outbound actions still cross policy, and one orchestrator owns any flow that needs judgment or a human door.
Session distillation into the knowledge plane and business-app operational agents are planned. Generic ingress is available through declared sources and POST /hooks/<source> with deduplication and trigger matching. Availability labels are maintained on the status page.