2026-06 – 2026-06 · repo

CORDON

A containment layer for AI agent swarms

1st place — AGI House — Agent Identity Build Day (37 teams)

An agent containment prototype with provenance taint, a credential broker, contact tracing and signed audit records. Its recorded evaluation uses handcrafted attacks and benign controls, rather than production traffic.

The failure I designed around

An inbox agent reads a hostile email, passes its instructions to a research agent, and that agent delegates to a coding agent. The coder then asks for a protected deploy credential. Each handoff looks like ordinary work; the agents can still authenticate correctly even though untrusted content has changed what they are trying to do.

I designed CORDON around that path: assume the injection reaches an agent, then restrict its authority at the tool and credential boundary. The goal is to contain the exposed path while letting unaffected agents continue useful work.

Put authority behind a runtime boundary

Instrumented tool calls, handoffs and credential requests pass through a Python reference monitor. Tools have configured trust labels: reading an email or web page marks the caller as tainted because of the source, without asking the model whether the text looks malicious. A handoff from a tainted agent propagates that state. Within a run, exposure cannot be cleared by moving the agent back to a healthy state.

The credential broker checks taint before calling its secret resolver. This ordering matters: fetching a secret and withholding it afterward would still bring it into process memory. The controlled fixture recorded secret leaks; tests also check that the resolver was not called for a denied request. The boundary depends on tool calls and handoffs being instrumented. It does not establish protection for arbitrary integrations that bypass the monitor.

Quarantine the path that carried exposure

When the broker denies a tainted agent's sensitive credential request, CORDON traces backward through the delegation graph to the origin of exposure, then forward to the agents it reached. Each edge records whether the sender was tainted at handoff time. That distinction keeps an earlier, clean delegation from implicating the orchestrator, and leaves an agent outside the exposed path unaffected.

Quarantine denies further broker requests and asks the sandbox adapter to freeze the affected agents. Credential “revocation” here means denial by CORDON's broker, not revocation of a vault service-account token. The sandbox integration is another containment action; it does not establish hardware isolation.

Exposure travels; credential authority stays at the broker
Untrusted input
Email or web content with a configured source trust label.
ToolProxy reference monitor
Instrumented tool read
Mark the caller exposed because of the source.
Agent handoffs
Propagate taint; record sender exposure at handoff time.
Credential broker
Check taint and requested scope before retrieving a secret.
Denied: tainted + sensitive
ToolProxy containment
Contact tracing / quarantine
Trace the origin and exposed descendants. Deny further broker requests and ask the sandbox to freeze affected agents.
The denied path never calls the secret resolver. Unaffected agents can continue.
Allowed request only
External secret resolver
Retrieve the requested credential only after the broker permits access.
Signed, hash-chained audit events support inspection and replay.
Illustrative path through instrumented interfaces. Exposure is provenance, not a content-classifier verdict. Broker denial is not vault-token revocation; a requested sandbox freeze is not proof of isolation.

Make the decisions inspectable

Decisions are recorded in an Ed25519-signed, SHA-256 hash-chained audit log. Verification checks the signatures and chain links for tampering; the log is an account of recorded events, not proof that every external action was observed.

I froze the typed event contract before building its consumers. The dashboard uses the same pure state reducer for live Server-Sent Events and scripted replay. Seeking backward recomputes state from an event prefix instead of trying to undo prior mutations. This let the interface be built against recorded events before the agent swarm was ready.

Compare attacks and useful work together

The recorded evaluation contains : ten handcrafted injections and seven benign controls. Attack variants include direct requests, social engineering, obfuscated wording and multi-hop handoffs. Some benign controls contain innocuous trigger words, so the comparison also tests the cost of a naive keyword detector. These results were measured against the recorded checkout on August 6, 2026.

Recorded outcomes on the same fixture
OutcomeCORDONKeyword baseline
Successful attacks0 of 10 ()6 of 10 ()
Benign tasks preserved6 of 73 of 7

That is of benign work preserved, respectively. The tradeoff is : a legitimate deploy request following untrusted input was denied. Agent-level taint is deliberately coarse; it records exposure, not whether a particular instruction is safe. I kept that case in the evaluation and disclosed it rather than tuning it away.

This is a bounded synthetic comparison against a naive keyword baseline. It does not demonstrate representative production coverage or superiority over other agent-security systems.

What is implemented, and what the demo illustrates

The repository contains the security engine, credential and sandbox adapters, signed audit records and an OpenAI Agents SDK swarm. The default demonstration uses a scripted attack and recorded event playback. In standalone mode, backend-dependent controls are omitted; running the real integrations requires provider credentials. The public replay does not establish current remote-service availability, which was not rechecked for this page.

The prototype keeps its state in memory, mirrors its Python and TypeScript event contracts manually, and freezes sandboxes serially. Persistent state, enforced contract synchronization and broader evaluations remain engineering work before making a production-readiness claim. This case study adds no new execution or evaluation evidence.

My contribution and the build process

I built CORDON with Claude Code as a research and implementation partner. My contribution was the threat model, the choice to contain exposure at the runtime boundary, the event contract, phase gates with exit tests, and the decision to report the false positive. AI-assisted implementation is part of the work; the agent swarm inside the product is the subject being contained, not the source of its safety decisions.

The first-place event result and 37-team field are recorded from my confirmation; an independent public award record is not linked here.

View the public repository · Watch the recorded demo · Back to the CORDON project

How it was built

Time:
About two days, solo — roughly six hours of preparation and a twelve-hour build day.
Tools:
Claude Code
My contribution:
The threat model, the decision to contain rather than detect, the 14-type event contract frozen as the first commit, the phase gates and their exit tests, and the choice to disclose the false positive instead of tuning it out.
Validation:
August 6, 2026 source record lists 22 automated tests; 20 ran offline in 0.34s and two required live credentials. These project checks were not rerun for this page.