A coding agent can say it finished a task. That does not tell you whether the last test passed.
A log can show that a shell command ran. It cannot, by itself, tell you whether the result is correct. And when a terminal goes quiet, you may be looking at a permission prompt, a long-running tool, or a session that has already finished its turn.
Those are three different questions. We keep trying to answer them with one scrolling terminal.
Recently, Thoughtworks' November 2026 Technology Radar described harness engineering at scale as one of its themes. A discussion in r/ClaudeCode asked a related question: why build an AI harness when Claude Code already exists?
I think the answer starts by separating three things we often put under the same label.
The model, the harness, and the recorder have different jobs
A model produces responses and proposes actions. A coding harness puts those proposals into a working environment: it supplies context, exposes tools, manages turns, enforces permissions, and handles results. Claude Code and Codex CLI already do substantial work here.
A recorder, in the sense I mean it, observes events produced by an existing harness. It records what the harness reports and makes that activity inspectable afterward—or while it is happening. It does not need to replace the harness or decide what the agent is allowed to do.
That separation matters. A permissions engine needs authority. A recorder needs evidence. Giving a dashboard authority merely because it watches events creates a second place where tool execution can change.
There is a precedent in backend engineering: traces and logs help you investigate a request, but a trace is not an HTTP response, and a trace viewer should not silently change authorization decisions. Agent tooling deserves the same distinction.
What an event can prove
Suppose an agent is asked to fix a failing API test. You inspect a record of the run and find a test command, a file edit, and a final message saying the bug is fixed.
You can make several claims about that sequence, but they have different evidentiary strength.
| Observation | What it supports | What it does not establish |
|---|---|---|
| A tool-call event was recorded | The recorder saw a call reported by the harness | The command achieved its intended result |
| A tool result reported success | The tool returned a success result | The code change meets the task's acceptance criteria |
| A subagent started | Work was delegated to another agent session | The delegated work was useful or correct |
| No new events arrived | The recorder has no newer events | The process is definitely idle, blocked, or dead |
| A turn ended | The harness reported the end of that turn | The broader engineering task is finished |
The trap is treating activity, progress, and correctness as interchangeable. They are not.
To establish correctness, you still need the changed files, relevant tests, a review of the behavior, and sometimes a human decision about the requirements. A recorder tells you where to look; it cannot make that decision for you.
Two coding CLIs, two different evidence sources
This gets interesting when you try to observe more than one coding tool.
Claude Code exposes events through hooks. An observer can receive notifications about session starts, tool use, subagents, turn endings, and other supported events. A well-designed observing hook can forward the event and exit without sending any instruction back to Claude Code.
Codex CLI stores rollout records on disk. An external tool can follow those files and reconstruct session activity. But a record of something that happened is not the same as a live permission-state signal. In particular, Codex approval requests are not available to the recorder through the rollout data used here.
These are different interfaces, so a single dashboard should not claim the same confidence for both.
The data flow can be described without pretending the providers expose identical APIs:
Claude Code -- event hooks ------\ >-- local event processing --> timeline / graph Codex CLI -- rollout files ----/ The diagram is an architectural sketch, not a protocol specification. An observer must still handle missing events, delayed writes, restarts, and incomplete session endings. For example, a Codex rollout that lacks a closing event is not proof that its process is still running.
This is where a useful visual interface can become misleading. A green dot, a timer, or a line connecting two agents looks definitive unless the software can explain how it obtained that state.
An evidence model should preserve uncertainty
If I were defining a small event contract for a recorder, I would preserve where each observation came from instead of reducing every source to one generic running: true flag:
// Conceptual example, not ccdeck's actual event schema. type RecordedEvidence = { source: "claude-hook" | "codex-rollout"; sessionId: string; observedAt: string; eventType: string; status: "observed" | "inferred"; }; An observed value would mean the source reported that event. An inferred value would mean the observer derived a state from incomplete evidence, such as a missing ending in a file. Neither value would mean verified correct. The recorder's job is to retain those distinctions all the way to its UI.
Why I built ccdeck outside the harness
I build ccdeck, a free, open-source local dashboard for Claude Code and Codex CLI. It shows sessions and supported subagents on a canvas, lets you inspect captured tool activity, and surfaces Claude Code sessions waiting for a person to respond.
Its two capture paths are deliberately separate: a one-way Claude Code hook forwards events to the local server, while a file watcher reads Codex rollouts. The resulting records can be viewed together, even though the underlying signals are not equivalent.
There is one design choice I care about more than the graph: the observing hook must not steer the agent. ccdeck's Claude Code forwarder posts an event, exits successfully, and writes no decision to stdout. The repository has a test intended to keep that behavior from changing unnoticed. You can inspect the source and the documented capture paths.
This is a narrow claim. The hook cannot approve, deny, defer, or rewrite a tool call. It does not mean ccdeck is completely read-only: installation adds a hook entry to Claude Code settings, and optional features can change local settings or account state. The README describes those effects.
And it is not an orchestrator. It does not assign coding tasks or turn a session into a managed workflow. I still start Claude Code or Codex in my terminal, and I still review the output where the work happens.
A local recorder also has a privacy boundary
"Runs locally" is useful information, but it is not a complete privacy policy.
ccdeck keeps session content such as prompts and tool-call details on the machine rather than sending that content in its usage reports. Usage reports are enabled by default, however, and include system metadata, IP address, and a stable hashed device fingerprint. The environment variable AGENTS_DECK_NO_REPORTS=1, set before the deck starts, disables those reports.
The product also has local-network discovery enabled by default. Its Browser Watch feature is enabled by default too and examines Chromium history for certain browser-navigation patterns. Those are real access surfaces, even though session content stays local. If you are evaluating a session recorder for sensitive work, review its permissions, default networking behavior, data retention, and uninstall procedure before installing it. The "What it touches" documentation is the relevant starting point.
A recorder can be useful without being invisible. The honest goal is to make its access explicit.
Try the distinction on your next run
If you already use Claude Code or Codex CLI, you can inspect one session and ask three questions: Which facts were captured? Which states were inferred? Which conclusions still require checking the code?
With Node.js 18 or later, start the dashboard:
npx ccdeck Then start your normal claude or codex session. The local dashboard normally opens at http://127.0.0.1:4317; if the port is occupied, use the address printed by the startup command.
If you prefer the desktop app, the official installers and one-line commands are on ccdeck.dev. For example, the documented macOS installer is:
curl -fsSL https://ccdeck.dev/install.sh | sh Read a downloaded script before piping it to a shell if that is your normal security policy. The first-run guide explains the hook and the reporting defaults. You can stop the Node-based deck with npx ccdeck --stop.
I would test one specific proposition, not whether the dashboard looks nice: Does its event history help you find evidence faster without pretending to certify the agent's answer? That is a useful bar for any agent-observability tool, including mine.
Claude Code already has a harness. I do not need another runtime to use it. I need to know what the runtime observed, what it could not observe, and exactly where my own review starts.
Sources: Thoughtworks Technology Radar, Vol. 35 · Reddit discussion on AI harnesses · ccdeck source and documentation · ccdeck first-run guide



