Skip to content

Agents Preview

Define an agent once, revise it safely and run any revision on demand.

An agent is a stable identity with a history of exact revisions. You can reach it from your editor, a chat app or another agent, and every call is checked and recorded on the way in. Changing an agent never touches work already running.

Talking to agents is built. Defining and running them is designed.

The protocols, the policy gateway, egress control and audit work today. The registry for definitions and revisions, workflows and connections are designed. Where it stands has the detail.

One agent, many revisions ​

An agent never changes in place. A change starts as a proposal, gets judged, and only then becomes the next revision. Sessions keep the revision they started on.

agent-pr-reviewerA stable identity. It never changes in place. Registry history
Revision 1Base

Every proposal starts from it.

  1. prop-b804WithdrawnWithdrawn by its author before anyone judged it.
  2. prop-9c21RejectedRejected by the verifier, with its reasons kept.
  3. prop-7f3aApprovedApproved, and becomes revision 2.supersedes prop-b804
Revision 2Active

Minted only when a proposal is activated.

  • A session started on revision 1 finishes on revision 1.
  • New sessions start on revision 2.
Only the activated proposal reaches the agent's history. Proposals that never ship leave the registry untouched.

Reach it from anywhere ​

Editors, chat apps, other agents and tools all meet on one message bus, each in the protocol it already speaks.

  • Your editorACPA stdio bridge and an HTTP and WebSocket serverBuilt
  • Chat appsChannelsTelegram todayBuilt
  • Other agentsA2AHTTP, REST and streaming, with a published agent cardBuilt
  • ToolsMCPOver stdio and HTTPBuilt
One message busNATSEvery protocol is carried over it
Your agentACP for editors and chat, A2A for other agents, MCP for the tools it calls.

Ways to send work

  • UnicastBuiltAsk one agent by name.
  • MulticastBuiltFollow a task as it happens. Every subscriber sees its events.Task events only
  • AnycastPlannedAsk any available reviewer, and one instance takes the work.No design yet

Every call is checked on the way in ​

Before a request from another agent reaches yours, the gateway confirms who sent it and runs it through each layer of policy. A refusal at any layer stops the call and is recorded.

At the public endpointProof of possessionCallers prove they hold their key on every request.Built
A2A gateway Built
  1. Caller identity The caller's signed token is checked. A request that names no caller never gets further.
  2. Relationships optionalIs this caller related to this agent?
  3. Rules Declarative allow and deny lists.
  4. Conditions CEL expressions over the request.
  5. Redaction A sandboxed module strips what the agent must not see.
Your agentSees only what passed every check.
Refused with a clear error, and audited

Every decision, allowed or refused, is written to the audit stream. The principal is fixed by the subject the request arrived on, so a header cannot re-attribute it.

Fenced in by default ​

A running agent gets only what its policy grants: where it may connect, what it may spend and which accounts it may use.

A running agentGets only what its policy grants
  • NetworkBuiltReaches only the exact destinations its policy permits, through an mTLS proxy.
  • IdentityBuiltProves which workload it is with attested certificates, not shared secrets.
  • AuditBuiltEvery decision is recorded. A permit that cannot be recorded is refused.
  • PolicyIn progressPermits, ceilings and holds on what an agent may do. Policies can only narrow, never widen.
  • CredentialsDesignedUses connected accounts through a proxy that adds the credential. The agent never sees the key. See Keys & Secrets.
  • Model accessDesignedWhich models it may call, and how much it may spend.

Work that spans agents ​

Larger jobs become workflows. Each step runs in a fresh session pinned to an exact revision, so a restart picks up where the work left off instead of asking a model to remember.

ImplementMake the change in a fresh session. agent-coder rev 4
Repeat until approved, up to its limit
Parallel
Code review agent-pr-reviewer rev 2
Security review agent-security rev 1
join
Rejected
Revise, then review again agent-coder rev 4
Wait for CIAn external check. No agent turn is spent while it runs.
DoneEvidence recorded for every step.

Every agent step runs in a fresh session, pinned to an exact revision.

  • SequenceThe next step starts when the last one is complete.
  • ParallelIndependent work runs at once, then joins.
  • RepeatA review loop with an exit condition and a limit.
  • WaitPauses for a check, a person or a delay without using an agent turn.
A restart rebuilds the run from its record, so finished work is never paid for twice.

What we promise ​

  • Running work never shiftsEach session pins one exact revision. Changing an agent never changes work already in flight.
  • Changes are judged firstA change to an agent is a proposal. It becomes a revision only after a verifier approves it.
  • Checked before it arrivesEvery call proves who sent it and passes policy before any agent sees it.
  • Nothing goes unrecordedAllowed and refused calls are both audited. A decision that cannot be recorded is refused.
  • Only the doors you openAn agent reaches only the exact destinations its policy allows. Everything else is refused.
  • Agents never hold your secretsCredentials are added on the way out, so the agent uses a connection without ever seeing the key.
  • Bring any runtimeClaude Code, Codex or your own agent. A planner, a coder and a reviewer are one kind of thing with different settings.

Where it stands ​

  • Editors talk to remote agents over ACPA stdio bridge for editors and an HTTP and WebSocket server, both over NATS.Built
  • Agent-to-agent calls through a policy gatewayA2A over NATS with caller identity, layered policy, redaction, audit and push notifications.Built
  • Tools over MCPMCP carried over NATS for stdio and HTTP. There is no tool registry yet.Built
  • Proof of possession at the edgeCallers at the public A2A endpoint prove they hold their key on every request.Built
  • Egress control and workload identityA proxy that admits only allowed destinations per agent, using attested workload identity.Built
  • Platform audit streamShared by the gateway and the egress proxy. Records that must be kept fail closed.Built
  • Agent discovery catalogThe catalog model and HTTP routes exist with an in-memory store. NATS storage is not wired.In progress
  • Policy bindingsContracts and an evaluator library exist. No service enforces them yet.In progress
  • Agent definitions, revisions and proposalsProtobuf contracts and the stream design. No registry service yet.Designed
  • Workflows across agentsSequence, parallel, repeat and wait, with every step pinned to a revision.Designed
  • Connections with injected credentialsAgents use third-party accounts through a proxy that holds the credential.Designed
  • Model access through the provider gatewayThe gateway serves health checks only. Routing and credential binding are designed.Designed

Learn more ​

Understand the design

Connecting and protecting

Released under the Apache License 2.0.