Cortex — Extreme Observability

What problem it solves

Multi-agent systems have a credibility problem: the more moving parts, the easier it is for a wrong answer to look right. Worse than visible failure is the invisible kind — the step that “succeeded” on garbage inputs, the confidence number that was really a storage default, the summary that quietly replaced the evidence. Witan’s entire thesis (many small models instead of one big one) is worthless if the handoffs between models can’t be inspected. Cortex is that inspection surface — and the discipline behind it.

The thesis

If you can’t see the work, you don’t have a system — you have a story about one. Every agent run must be its own recorded event carrying the verbatim input it received, the exact assembled prompt it ran with, and the verbatim output it produced. Summaries may sit on top of the evidence but never replace it. And the surface that displays all this must always be the truth — the one rule in the project with no exceptions: Cortex must always be the truth.

Try it — watch a task move through Cortex

The diagram above is the shape; this is the thing itself. Pick a task and step through what the swarm actually does with it — every model’s input, the prompt it runs, the output it hands back with a confidence and a source, the guard that verifies the work, and the final decision to act or ask. It runs entirely in your browser and never touches the live system.

Interactive · runs in your browser

⛓ gapped from the live system

Watch Cortex think

Pick a task below and watch the swarm handle it — each small model appears as a real Cortex event: its host, its model, the confidence, the verification, and (click any step) the verbatim input, the exact prompt it ran, and the output it produced. When a task has consequences, Witan surfaces a propose-only card instead of acting silently. This is Witan's real observability schema, replayed on representative traces, entirely on this page.

Select an input

▶ Run through Cortex Step Reset Watch Fast Instant

CORTEX · EVENT LOG & TRACE

Pick a task and press Run — events stream in here as each agent finishes, newest work at the bottom. Click any event for its verbatim input and output.

Representative, sanitized traces on Witan's real Cortex schema — internal hostnames shown as role labels, no real data, and the live system is never contacted. Real captured traces drop in with the same shape.

Key features

• Lossless run records. Every agent and tool call is a traced node — chained by parent-run links into full workflows — with checkpoint I/O preserved verbatim at every step.
• Field-level verification. A guard checks that every field in a step’s output traces back to something in its input. A date that appears from nowhere is flagged as a hallucination even if it happens to be right — the 0+1=2 failure (right answer, broken derivation) is treated as worse than a visible error.
• Diagnosed escalation. When work blocks or climbs to a bigger model (the ladder’s rungs live with the fleet), the trace records why, in one of five diagnostic buckets (harness fault, model capability, task too big, needs decomposition, missing tool). Failure gets a taxonomy, not a shrug.
• Plain-language explainability. A trace-summarizer turns any agent chain into one readable paragraph; every card in the interface answers “why am I seeing this?” in a tap; a board narrator compresses the fleet’s whole day into six plain lines.
• Render honesty. Unmeasured values render as nothing — never as a default dressed up like a measurement. This came from a real bug (0% confidence stamped on everything) and became doctrine.
• Observability of the builders, too. Even the chat between me and the system is mirrored as observation events — the same transparency applies to the humans-and-Claude layer that builds Witan as to Witan itself.
• Attribution and a self-sufficiency score. Every executed step is stamped with a plan-time verdict (who should do this) and an executor mark (who did), and those roll up into a tracked self-sufficiency score — how much Witan accomplished on its own versus how much still needed the frontier model. It turns the project’s real goal (remove the outside dependency) into a number I can watch move, which is the honest version of “is this actually working?”
• Answers carry provenance. When I ask a question, a retrieval pass searches my own stores and answers with its sources attached — the reply points at the records it came from, rather than the model reciting from memory. In an observability product, an answer you can’t trace is just a confident guess.
• Complete coverage — tools are nodes too. Not just the agents: every deterministic tool call is now its own Cortex node, which restored the last observability invariant (nothing that does work is invisible). And attribution reconciled to full coverage — every observed run attributes to something, so the count can’t quietly undercount. This is what makes the self-sufficiency score trustworthy rather than merely suggestive: a number about “how much ran locally” only means something if everything that ran is in the ledger.

Highlights

• Cortex is where the project’s hypothesis gets proven or falsified — “can Witan do X?” is answered by a trace showing every wire, prompt, and verified field, or by an honest diagnosis of why not and what would change that.
• The verification guard’s premise — outputs must be derivable from inputs, not merely plausible — is the single idea from this project most transferable to any AI system.
• The self-sufficiency score is the rare metric that’s supposed to make its own author redundant: the whole point is to drive the number that measures how much a human-plus-frontier-model still has to do toward zero.

Development log

July 20, 2026

Cortex closed its own coverage gaps. Deterministic tools became first-class Cortex nodes — restoring the observability invariant that everything which does work is traceable, not just the LLM agents — and attribution reconciled to complete coverage (every observed run attributes; the roster’s nodeless agents now bind by observed runs, so nothing undercounts). Together these make the self-sufficiency score honest: it now rests on a ledger where nothing that ran is missing. Also this week, the Knowledge surface moved off the apex into a Cortex tab, and Witan began self-authoring its own documentation from corrections.

July 16, 2026

Observability grew a spine and a scoreboard. A single reconciler now stamps origin and attribution across every task; an acceptance gate drains work to verified or blocked and fails closed (nothing “passes” by default); a ready-boundary reaper alerts on tasks that age without moving instead of letting them rot silently; and the attribution roll-up became the self-sufficiency score. Two hardenings worth noting for a security-minded reader: approved cards now execute server-side rather than through an agent’s shell (removing a command-execution surface), and a before-state now rides every mutating action, making undo a true invariant rather than a per-feature afterthought. Retrieval answers now come back with provenance attached.

July 8, 2026

Page created. Recent: the trace-summarizer and board narrator (plain-language layers over raw traces), the why-am-I-seeing-this explainer on every card, the render-honesty pass, and chat mirroring — every conversational turn with the system now emits an observation event like any other agent run.