Open format · version 0.1

The Crew Record

Crew Lens draws what a crew of coding agents did from one document, the Crew Record: who worked on what, who reviewed it, which messages went where, who waited on whom, and the moments worth finding again. Its format is open, under CC BY 4.0, so other harnesses can write it and other tools can read it.

JSON Schema, version 0.1 See the waits in 2D See it replayed

Why a format of our own, now

We run a multi-vendor crew. On display here are Anthropic's Claude Code and OpenAI's Codex; our meta harness also supports Google Antigravity, and Kimi and other players are being added. We need one record of that crew that every vendor's agents feed, in the crew's own terms: work items, reviews and their rounds, sprints, messages, stalls, drift, holds and seats. That could not wait for a standard, and it should not stay ours, so it is an open format. It is meant to sit on top of OpenTelemetry rather than compete with it: version 1 is to use OpenTelemetry's names wherever one exists (the gen_ai, messaging and vcs conventions) and keep a namespace of its own only for what has none.

We commit to following that work. As OpenTelemetry's conventions for agents mature, the Crew Record will move toward them, and what the community adopts from it should end up in the standard itself.

What it holds

One JSON document per crew and stretch of time. Times are in UTC, and agents, work items and sprints keep the ids they have in the harness that wrote the record.

`agents`	The crew: each coding agent and the human operator, with its model family, model and reasoning effort, its roles (producer, reviewer, sprint master), its projects, and when it started.
`work`	Work items: who built each one and who reviewed it, its states and review rounds, its reports, and what it changed in git (files, lines added and removed, commits).
`sprints` `projects`	Sets of work items with one goal, their members, and how much code their scope covers.
`deliveries` `events`	The traffic: each message between agents and with the operator, as metadata (sender, recipient, kind, size, when it was sent, seen and answered), and the time-ordered stream the replay plays.
`fanouts` `stalls` `findings` `cyber` `models`	The moments worth finding again: sub-agent fan-outs, stalls, the Sentinel's findings of drift, the cyber classifier's warnings and holds, and the model and effort each agent asked for against the ones it was served.
`nudges` `glow`	The operator's nudges, and a coarse activity series for each agent.
`waits` `approvals`	New in version 0.1. Who waits on whom: for each wait, the crew member that waits, the one that owes the next move, over which work item, since when, picked up or not, and when and how it ended (answered, decided, cancelled, or superseded when its work was set aside). Decisions asked of the operator are waits too, from when the work reaches the operator.
`roles` `spikes`	New in version 0.1. The operator and the crew's standing roles, a sprint's plan (`sprints[].plan`: items, owners, dependencies, estimates), a work item's state history (`work[].states`), and spikes, the assignments that excuse agents from sprint work for a while.

The wait graph

A crew of agents waits on itself: a reviewer waits for something to review, a producer waits for the review, an agent waits for the operator's decision. Version 0.1 records each of those waits. What a reader makes of them is computed, at each moment of a replay, from the waits open then: chains (one agent's wait holding up others downstream), loops (agents waiting on each other across work items), deadlocks (a loop on one work item) and the agent to unblock first, the root of the longest chain. None of it is stored, so it stays in step with the waits it comes from.

A wait can end without an answer. When its work item or its branch is set aside, for a spike or a change of plan, it ends as superseded and stops counting; without that end, a wait the crew walked away from looks the same as a wait the crew is stuck on.

A wait on a person starts when the work reaches them, not when the work is filed. Counted from the filing, it takes on the agents' own producing and reviewing, which are waits of their own.

How Crew Lens draws it, in 2D

What it leaves out

Message bodies, prompts, code and diffs. A message is in the record as who sent it to whom, when, of what kind and how large; what it said is not. A work item can carry its title and its commit subjects, and optionally its brief and its producer's last progress note. A harness that wants to keep its work private can leave all of these out.

Where it runs

Crew Lens is an app, not a hosted service. It runs next to your coding agents, reads the Crew Record where your harness writes it, and draws it in your browser. It does not send the record, or anything else about your crew, to RAIVEN or to anyone else. Your agents are yours, and so is their track record.

The coding agents themselves are another matter. Claude Code, Codex and their peers send your prompts and code to their vendors to do the work, under those vendors' terms, with or without the lens. The lens adds nothing to that traffic.

Where it comes from

Today one harness writes the Crew Record: RAIVEN's own, which runs a crew of Claude and Codex agents, from its store of work items, reviews and messages. That is where the format started, not a limit on it. It is open so that other harnesses can write it too.

Next, the series for each agent (how full its context window is, when it compacts, how busy it is) are to come from the coding agents' own session files, read on the same machine: Claude Code's session transcripts and Codex's session rollouts. After that, adapters for plain Claude Code and Codex setups, with no RAIVEN harness in between.

Real, derived or synthetic

Each row can say where it came from, in its source field. A row read from a primary record, such as the harness's store or an agent's transcript, is real. A row computed from real ones is derived, such as the lines of code under a sprint's scope. A row made up for a demo is synthetic, and says so.

A part that is absent was not recorded; it does not mean that nothing happened, and a reader must not count it as zero. A crew with no stall feed has not been shown to be free of stalls.

The record behind the timeline figures on this site is of the mixed kind: its work items, reviews and convergences are real, and so are its cyber warnings and holds, read from the agents' session logs; 1,068 of its messages are real but were moved in time into their work windows (synthetic, with the recorded time in retimed_from); and its other incident marks are synthetic data, though each kind of incident is real and observable in the source crew.

Versions

Version 0.1 (22 October 2026, the current version) adds the wait graph: waits, approvals, roles, spikes, sprint plans, work items' state history and cost, and raw output tokens beside the activity series. It is backward compatible: all of it is optional and nothing in version 0 changes, so every version 0 document is a valid version 0.1 document. A reader of version 0 that ignores the fields it does not know, as the format asks, reads a version 0.1 document as before; a strict version 0 validator turns one down for its schema_version alone.

Version 0 is superseded by version 0.1 and stays online, so documents and validators that point to it keep working: crew-record.v0.schema.json. It is the format Crew Lens's 3D scenes read; files written by current builds may carry its earlier identifier raiven.crew_lens_fixture.v1, which names the same format.

Version 1 is planned to add:

for each agent, context window use and compactions, activity and liveness, in place of the coarse activity series;
token usage per turn, with the model and effort served, and a dated price table, so that cost is computed rather than carried;
a required provenance field on every row: real, derived or synthetic (version 0.1 has it as an option);
ingest as NDJSON or OpenTelemetry (OTLP), so that a harness can stream the record as it goes;
a mapping to OpenTelemetry's conventions for generative AI (its agent conventions are still marked Development), with crew extensions for messages, reviews and sprints;
a validator, test records, and adapters for Claude Code and Codex.

The schema

The format is written down as a JSON Schema (draft 2020-12). Fields it does not name are allowed, and a reader that does not know them ignores them. A shortened example:

{
  "schema_version": "crew-record.v0.1",
  "generated_at": "2026-08-31T09:00:00Z",
  "agents": [
    { "id": "c2", "family": "claude", "model": "fable-5.1", "effort": "max",
      "roles": ["producer", "reviewer"] },
    { "id": "x4", "family": "codex", "model": "codex-sol", "effort": "extra",
      "roles": ["producer", "reviewer"] }
  ],
  "work": [
    { "id": "W3c", "producer": "c2", "reviewer": "x4",
      "created_at": "2026-08-30T19:02:11Z",
      "work_state": "completed", "review_state": "converged", "round": 2,
      "git": { "files": 7, "insertions": 312, "deletions": 41, "commit_count": 3 } }
  ],
  "events": [
    { "at": "2026-08-30T21:14:05Z", "type": "delivery", "kind": "review request",
      "from": "c2", "to": "x4", "size": 1840, "work": "W3c" }
  ],
  "cyber": [
    { "agent": "x4", "work": "W3c", "action": "hold",
      "classifier": "model vendor's cyber classifier",
      "started_at": "2026-08-30T23:05:12Z", "ended_at": "2026-08-31T08:52:30Z",
      "source": "synthetic" }
  ],
  "waits": [
    { "waiter": "c2", "owner": "x4", "kind": "review", "work": "W3c",
      "started_at": "2026-08-30T21:14:05Z", "claimed_at": "2026-08-30T21:20:40Z",
      "ended_at": "2026-08-31T08:58:12Z", "provenance": "synthetic" }
  ]
}

Licence

The Crew Record, this description of it and its JSON Schema, is licensed under Creative Commons Attribution 4.0 (CC BY 4.0). Use it, share it and adapt it, commercially too, as long as you credit it (“Crew Record by raiven.eu”, with a link to this page), link the licence and say what you changed.

Early adopters and partners

Crew Lens is being readied for release. Early adopters get early access when it ships, and a chance to shape it to their needs.

Partners who already offer agentic tools can bundle Crew Lens with them, or offer it under their own brand.

Become an early adopter Partner with us

To write the Crew Record from your own harness, or to comment on the format, write to info@agenticobservability.app.

Last updated 20 October 2026.