[ Byte 2.2.5 · One workspace ]
Keep the work worth keeping.
Carry the task, useful changes and recorded checks across Claude Code, Codex, OpenCode and Superset. Pick up an investigation without piecing it together again.
The recorded night's delegation, drawn. 194 agents: 34 session main agents and 160 spawned by another agent, joined by 160 lines. Eleven rows, one per level of nesting; the deepest chain on the record ran eleven levels and holds one agent per level below the third. One agent spawned 85, the widest fanout of the night. Scrolling runs the ten hour watch and each agent appears when it started; 193 finished and one was still running when the record closed.
Fig. 00 · The recorded night's delegation, in three dimensions. Every bead is an agent, every line is one agent asking another to run, and depth down the frame is depth in the record.
- Measured
- the counts above, and the ten hour watch the scroll runs.
- Staged
- the arrangement, the pose, and when in the night each agent starts.
A session drawn as a single mark. The mark's length is the session's wall clock span and its thickness is the tokens that passed through it. Underneath the spine, one strand per agent alive at that moment. This one is drawn at the mean of the 34 recorded sessions: 4 hours 49 minutes long, 4.7 subagents, and 12.3 million tokens, which is the night's 416.9 million divided by its 34 sessions. A tick out of the top edge is a compaction. A bar through the mark is an interruption. Sessions that called no tool and spawned nothing draw as one short identical tick, because that is what they are.
Fig. 01 · One session, drawn. Length is the span, thickness is the tokens, each strand is an agent alive at that moment.
- Measured
- the night's mean session: 4h 49m, 4.7 subagents, 12.3M tokens (416,900,000 / 34).
- Staged
- where the compaction notch and the interruption bar fall along the span.
[ Launch film · 03:09 ]
See the work behind the terminal.
One view for the agents running now, the sessions they leave behind and the cost of getting the work done.
Byte brings Claude Code, Codex, OpenCode and Superset into one workspace. The film includes narration and open captions.
Original Byte footage and narration. Music: “Cipher” by Kevin MacLeod, CC BY 3.0.
One session, read span by span
Replay · the night's widest session, cut into its nine spans
Measured the proportions, the fanout, the compactions, the waits. Staged the sweep reading them.
Prompt · read · plan · delegate · collect · compact · wait · verify · land
The night's widest session cut into nine spans, drawn in true proportion and read left to right. The sweep stops three times. On delegate, where one agent spawned 85, the widest fanout on the record. On compact, where the transcript filled and was compacted with no hook fired, recovered from the disk. On wait, where the run stopped on a person rather than on the machine while the clock carried on. Everything else it passes: prompt, read, plan, collect, verify, land.
[ 02 · Delegation ]
You start one agent. It starts the rest.
Nothing in the terminal tells you which agent hired which, or how deep it went before it stopped.
Delegation across 34 recorded sessions, drawn as four columns with edges running left to right. Column one, origin: 34 nodes, one per session. Column two, main agent: 34 nodes, one per session. Column three, spawned by a main agent: 103 subagents, made up of 90 general-purpose, 10 Explore, 2 compaction and 1 fork. Column four, spawned by a subagent rather than by a main agent: 57 further general-purpose agents. That is 160 subagents, and 194 agents once the 34 main agents are counted. The agent type general-purpose appears in two columns on purpose: the split is a partition of who did the spawning, not of what was spawned, and it is the only reason recursion can be drawn as a forward edge instead of a loop.
Fig. 02 · One night of delegation, in four columns.
- Measured
- 34 origin, 34 main, 103 spawned by a main agent, 57 spawned by a subagent. 160 subagents, 194 agents in all.
What the monitor removes
Agents misbehave quietly, in the background, at scale.
You keep one terminal per agent and scroll back through all of them to find out which.
You grep transcripts and add token counts up by hand to find out what it cost.
The trail is already on disk.
[ 03 · Capture ]
Native events show the present. History completes the record.
Each integration keeps its own identity and capabilities. Byte reconciles supported events and persisted history without duplicating sessions, usage or child-agent links.
An event column, seven rows, each stamped with the hook that produced it. At 23:02:41 SessionStart, main. At 23:02:44 PreToolUse, Read. At 23:02:46 PostToolUse, Read, 1.2K tokens. At 23:06:31 no hook at all: a compaction, recovered from the transcript on disk. At 23:11:08 SubagentStop, Explore, 41.6K tokens. At 23:12:55 no hook at all: an Esc cancel, recovered from the transcript. At 23:14:19 Stop, main. Five of the seven rows came from hooks. Two came from the JSONL transcripts under ~/.claude, because nothing fires a hook for them. Fleets started by the Workflow tool fire no hooks either and are rebuilt from the run journals left on disk. Sessions created by Cursor on the same machine are imported the same way, because Cursor uses the same on-disk layout; nothing records which application created a session.
Fig. 03 · One capture, including its holes.
- Measured
- the eight hooks, and the three things that fire none of them: /compact, an Esc cancel, and a subagent's own tool calls.
- Staged
- the seven rows and their timestamps.
- A trail with no holes is a trail somebody drew
- Rows no hook reported arrive marked, not smoothed over
- One key, one unique index: an overlap is a no-op
[ 04 · The screens ]
One workspace, six clear destinations.
Home, Work, Sessions, Insights, Library and Settings keep the active integration, project, machine and date scope visible.
A board of cards in columns. The agents view has four: active, waiting, completed and error. The sessions view has five, adding abandoned. Cards move between columns as the night runs. Across the whole record, 194 agents were seen, 193 of them reached a completed state, one was still running when the record closed, and the agent success rate was 100%. The error column is drawn all night and stays empty, because an empty column is a fact worth telling and a board whose columns come and go cannot be scanned twice the same way. Waiting is the useful column: it holds the agents that are stopped on you rather than on the machine.
Fig. 04 · The board, mid-night. Active, waiting, completed, error.
- Measured
- 194 agents, 193 of them completed, one still running when the record closed, and no agent failed.
- Staged
- which cards sit in which column at this moment in the replay.
[ 05 · Tasks ]
Everywhere else it reads a trail. Here it leaves one.
A sentence, or a GitHub issue, becomes a worktree, an agent, your project's checks and a branch. How far it goes without you is a setting with three positions.
A strip of ten task states in lifecycle order: draft, queued, preparing, running, checking, ready, landing, landed, and off the main line, blocked and cancelled. One task card walks the strip as the clock runs. Underneath, four stamps: queued at 22:47, running at 23:02, checking at 03:29, landed at 03:41. Autonomy is a per-project setting with three positions: prepare the checkout and stop, run the agent and stop for review, or carry a passing task through to a merge. Four refusals hold in every position, and they are listed under this figure. When it cannot land cleanly it says which of those it would have had to break, and the task waits on the board with the reason on it.
Fig. 05 · Ten states, one task, and four things it will not do.
- Measured
- the ten states and the three autonomy positions the product ships.
- Staged
- the task riding the strip and the four timestamps under it.
Four refusals, in every position
- Refusal 1 / 4It will not force a push.
- Refusal 2 / 4It will not stash your uncommitted work.
- Refusal 3 / 4It will not create a branch you have not made.
- Refusal 4 / 4It will not delete a directory it did not create.
- Merging to your default branch unwatched is a separate opt-in, off by default
- Several tasks at once, each in its own checkout of the same repository
[ 06 · The record ]
Recorded evidence, with its limits shown.
This reference night remains a transparent product specimen. Live views label missing, stale, estimated and partially collected data instead of turning it into zero.
The recorded night in totals. 34 sessions. 194 agents, main agents included, of which 160 were spawned by something else. 193 agents reached a completed state and one was still running when the record closed. 23,900 events. 416.9 million tokens of every kind. 94% of those tokens were cache reads. $366.65 spent. 0 bytes sent off the machine. The mean session ran 4 hours 49 minutes. The mean session spawned 4.7 subagents. The deepest parent chain observed was 11, counting the main agent as depth 1. The widest fanout observed was 85 children from a single agent. No agent failed.
Fig. 06 · The night in totals.
- Measured
- every value in this figure, in full.
[ 07 · The bill ]
Almost all of it was re-reading what it had already read.
Four token buckets, one bill.
Four bars against one rule standing for 416.9 million tokens. Cache read 391,886,000 tokens, 94.0% of the night. Cache write 11,256,300 tokens, 2.7%. Input 10,005,600 tokens, 2.4%. Output 3,752,100 tokens, 0.9%. That is 35 cache reads for every cache write, which is what heavy delegation looks like: every subagent reads a context somebody else paid to write.
Fig. 07 · Where 416.9M tokens went.
- Measured
- the four buckets, summing exactly to 416,900,000.
- Staged
- the order the four bars arrive in.
[ 08 · The boundary ]
The answer isn't a privacy policy. It's a drawing of the whole path.
A diagram of the whole path, with a rule drawn around the parts that stay on this machine. Inside the rule, left to right: hooks, the handler, 127.0.0.1, SQLite, the screens. The database is one file at ~/.claude/byte-agent-monitor/dashboard.db in WAL mode. Two notes along the bottom of the rule: unreachable from the network, and DASHBOARD_TOKEN required if you expose it. One dashed arrow leaves the rule, and its label reads sent 0 B.
Fig. 08 · The trust boundary. Five stages inside the rule, one arrow across it.
- Measured
- bytes sent over the recorded night: 0.
[ 09 · The obvious questions ]
Four questions you were going to ask anyway.
- Will it slow my agent down?
- Collection uses bounded handlers and background reconciliation. A collection failure does not stop the agent. Byte shows disconnected and incomplete capture explicitly; checks and model work run only through their configured controls.
- What if the server is not running?
- The agent carries on while Byte loses its live view. On reconnect, Byte reconciles supported persisted history and queued events. Recovery depends on the native integration and retained files; missing coverage remains visible.
- Which coding agents does it support?
- Claude Code, Codex, OpenCode and Superset. Switching changes the workspace view, while every connected collector keeps running. Agent identity and hosting application remain separate. Collection, history, execution and resume each show their own availability in Integrations.
- What does it cost?
- Two dollars a month to read your own machine. The tiers are on the pricing page.
What you still have when the server is down. One condition sits at the root of this tree: the server is not running. It has 3 branches, one per consequence, and each one ends in what you are left with. Branch 1 of 3, the agent: a tool call runs, then the hook posts to 127.0.0.1, then the post fails, then the handler exits 0 anyway, then the next tool call runs. You keep your agent, running. It continues after the bounded handler exits. Branch 2 of 3, the live view: nothing reaches the server, then no screen updates while it is down. You lose the live view, for as long as the server is down. Branch 3 of 3, the record: the transcripts under ~/.claude are still being written, then the server comes back, then its sweep runs every 30 seconds by default, then available supported history is imported. You keep the retained history. Unavailable data remains a capture gap. Recovery depends on the native integration and retained files.
Fig. 09 · What happens when the server is not running.
- Measured
- the fail-safe handler contract the product ships.
[ 10 · Run it ]
Install Byte 2.2.5, then connect the agents you use.
Use the desktop build on Windows, macOS or Linux, or run from Node 20 or newer. Existing records and appearance choices remain in place when you upgrade.
Byte 2.2.5 for Windows, macOS and Linux. Desktop downloads and checksums.
Define what should work, check the exact revision and keep the useful parts of an attempt. Requirements, review, investigations and verified lessons stay beside the task. Max adds combined-task rehearsal and explicitly enabled bounded recovery. Read what changed in 2.2.
npm run setup # dependencies, and link the byte CLInpm run install-hooks # forward Claude Code events to Bytenpm run dev # server on :4820, client on :5173# production: one process serving everything on :4820npm run build && npm start# something on screen straight awaynpm run seed # three demo sessions
$ npm run dev server on 127.0.0.1:4820 importing transcripts from ~/.claude ok 34 sessions, 194 agents, 23.9K events ok 0 B sent. It is all on this machine.
A terminal block with the install. npm run setup installs dependencies and links the byte CLI. npm run install-hooks writes the eight hook entries into ~/.claude/settings.json. npm run dev starts the server on port 4820 and the client on port 5173. For production, npm run build and npm start serve everything from port 4820 in one process. npm run seed puts three demo sessions on screen. The server installs the hooks itself when you run it directly on the host, so the second command is only needed if that fails or if you run in a container. Start the server before Claude Code: hooks only reach a server that is already running.
Fig. 10 · The install, in full.
- Measured
- the commands the product ships, the ports it binds, and the totals a first run prints.
- Staged
- the replay beside them, and its pacing.