Product

01/how it works

The whole run, not one call.

Boxdawn reads the whole run, not one call at a time. Today it shows the work your agents did twice. Next, it stops the action that should never run.

Built for moments like these:

pattern
repeat

The same agent runs on the same inputs again, with no new information in between. The cost breakdown in the JSON report keys it provable_duplicate, which is why the dashboard still joins on that name; the waste-rate block beside it uses repeat.

pattern
context_resend

Every API call re-sends the whole conversation. On long agent sessions this compounds to ~97% of input tokens as re-sent context (byte-exact chunk match).

pattern
redundant_read

The same file is Read multiple times without intervening writes. Common in coding agents that lose track of what's already in context.

pattern
duplicate_creation

A tool that changes something outside the agent runs twice on the same input, and the two runs come back with different ids: the second call created a second thing. A matching id is the same object, and a tool that returns no id is not judged either way.

pattern
semantic_duplicate

Two message chunks with different bytes but the same meaning (paraphrased re-send). Detected by the opt-in LLM-judge layer: off by default, requires API key.

Opt-in only · requires ANTHROPIC_API_KEY

pingpong requires genuinely multi-agent traces; single-agent coding sessions and Toolathlon are not expected to produce it.

pingpong is implemented but is not one of the cards above: the report gives a pair that name only when the pingpong detector itself produced it, and the waste-rate metric excludes it by name.

note: a fourth candidate pattern, regen_handoff, was descoped after failing pre-registered criteria. See Proven / Not Yet.

02/reference

What Boxdawn knows about.

Tool categories
  • read_only
  • side_effect
  • payload_dependent
  • declarative
Frameworks
  • LangChain / LangGraph
  • CrewAI
  • LlamaIndex
  • OpenAI Agents SDK
  • Smolagents
Detectors
  • find_repeat_candidates
  • find_pingpong_candidates
  • find_context_resend
  • find_redundant_reads
  • find_llm_judge_semantic_duplicates
Input formats
  • Boxdawn Trace JSON
  • OTel SDK JSON
  • Claude Code JSONL
  • Toolathlon JSONL
  • OpenInference nested
  • RedundancyBench
Register your tools (clew.yaml)
version: 1
tools:
  search_web:    { category: read_only }
  create_ticket: { category: side_effect, entity_id: response.ticket.id }
  run_python:    { category: payload_dependent }
  finalize:      { category: declarative }
03/report

One public trace, measured live.

resent input tokens
1,413,682 of 1,596,520 (88.5%)
resent input cost
$0.903964 of $1.595870 (56.6%)
waste over total analyzed
$0.903964 of $1.972395 (45.8%)
resent chunk occurrences
1,050

Measured 2026-10-28 by uploading davanstrien/agent-race-traces (claude-code.jsonl, a Claude Code session on claude-opus-4-7, CC-BY-4.0) to the hosted analyzer, which reported boxdawn 0.5.24. Upload the same file and you get the same figures. Two denominators appear above and they are not interchangeable: 45.8% is waste over total analyzed cost, input plus output, and 56.6% is resent input cost over LLM input cost alone. claude-opus-4-7 is in our price table, so the dollar figures are not at a fallback rate. This is one public trace and not a corpus average.

Upload the same trace →
in the browser
Drop a trace. No account.
Drop a trace. No account.
The analyzer runs. Seconds, not minutes.
The analyzer runs. Seconds, not minutes.
04/reproducible

Check the numbers yourself. Nothing to install.

Four detectors (repeat, context resend, redundant read, and duplicate creation), all deterministic. Same trace in, same report out, every time. Upload the public sample trace on the analyze page, with no account, and you get the same 88.5% this page cites.

Works with OpenTelemetry SDK JSON and OpenInference trace exports: LangGraph, CrewAI, LlamaIndex. OTLP proto-JSON is not yet supported.

deterministic-firstdeterministicOTel / OpenInference
Try it →
05/roadmap

Where we are on the chain.

Boxdawn is a chain: monitor → detect → block → alert → fix → govern. Detection is the link that runs today, as a service on the traces you upload. The rest is being built, and this page is where you can check which is which.

Running today
  • hosted analyzer, no account
  • four deterministic detectors
  • cost from real usage fields
  • accounts + per-project history
  • daily waste rate, by session date
  • API keys for CI and scripts
  • guard plugin for Claude Code: blocks or asks before risky commands run
Building next
  • catching agent errors before they spread
  • block alerts (email, Slack)
  • auto-fix
  • policy and governance
  • stopping runaway loops
  • budget guard for Claude Code, at a dollar cap
  • real-time monitoring
Alerting is specified and pre-registered: the comparison rule, the volume floor and the firing threshold were frozen in writing before any of it was implemented, so the first version cannot be tuned after the fact to look good. It is not implemented yet. Nothing in the right-hand column is available today, and if a capability appears in neither column, we have not planned it.
We killed real-time waste blocking ourselves. It scored precision 0.6333 against a 0.70 bar we wrote down first, so it did not ship. Blocking destructive actions and agent errors before they run is a different check. The first half shipped on 1 November 2026 as the guard plugin for Claude Code; catching agent errors is still being built. The kill is recorded in our alert pre-registration, which also states that the alert cannot predict anything. Real-time monitoring and alerting are a different claim, and those are on the list above.
Boxdawn diagnoses; it does not fix. No measured cost savings yet. We report what was found, not what was saved.