Product
Cheap filter first, expensive check second.
Boxdawn reads your trace as a graph and runs a two-stage cascade. The structural pass finds candidate waste in microseconds. The semantic pass looks only at what survived, never at everything.
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.
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).
The same file is Read multiple times without intervening writes. Common in coding agents that lose track of what's already in context.
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.
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.
What Boxdawn knows about.
- read_only
- side_effect
- payload_dependent
- declarative
- LangChain / LangGraph
- CrewAI
- LlamaIndex
- OpenAI Agents SDK
- AutoGen
- Smolagents
- find_repeat_candidates
- find_pingpong_candidates
- find_context_resend
- find_redundant_reads
- find_llm_judge_semantic_duplicates
- Boxdawn Trace JSON
- OTel SDK JSON
- Claude Code JSONL
- Toolathlon JSONL
- OpenInference nested
- RedundancyBench
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 }A real report.
# Boxdawn Waste Report - **trace_id**: `7f309fce-093f-412d-be64-cbd2860481f3` - **analyzed**: 2026-09-16T08:15:25Z - **detector params**: φ=0.514345, N=2, model=paraphrase-multilingual-MiniLM-L12-v2 ## Cost summary - **Total analyzed**: $2.524880 - **Total waste (detected)**: $1.665249 (66.0%) - **Cost accuracy**: `accurate` Breakdown by detector: - repeat: $0.000000 - context_resend: $1.665249 - redundant_read: $0.000000 _Cost attribution across four detectors: repeat, context_resend, redundant_read, semantic_duplicate. A detector that did not run has no row -- absence here is not a measured zero. `repeat` is keyed `provable_duplicate` in the JSON report (same cascade detector, key kept for compatibility). Not the same four as the waste-rate line, which unions repeat, context_resend, redundant_read and duplicate_creation._ ## Context resend Message chunks that appear in the input of two or more LLM calls within this trace, byte-exact by sha256. System-role chunks are exempt. First occurrence of each chunk is not counted (it is the necessary payload); occurrences from the second onward are recorded as resent. - **events**: 1720 resent chunk occurrence(s) - **resent input tokens**: 2056739 of 2238628 (91.9%) - **resent input cost**: $1.665249 of $1.931955 (86.2%) - **cost accuracy**: `accurate` ### Top offenders (by LLM call) - span `msg_01S2rTDtWwK9s5G15AiHu3Zf`: 22 resent chunks, 65715 tokens, $0.253172 - span `msg_01MwTSZsxhZnFzS2DHbWoe7k`: 68 resent chunks, 148485 tokens, $0.206537 - span `msg_01GmBJvkryprm1pCB6tMtdc5`: 123 resent chunks, 162168 tokens, $0.138267 - span `msg_011ZR8iNqiod3YbbDs4UCgUp`: 225 resent chunks, 211788 tokens, $0.133689 - span `msg_01K8wsAnXZ7RqcvVdkrsP3LX`: 117 resent chunks, 130004 tokens, $0.092611 --- _Note: detection thresholds are frozen at synthetic values (phi=0.514345, N=2); real-trace evaluation is ongoing, but parameters have not been recalibrated. Borderline matches (cosine near phi) deserve human review. This applies to non-tool spans; tool spans use exact sha256 identity._ _Cost is estimated saving potential, not measured: it assumes the wasted output is re-consumed each subsequent turn (structural assumption). Range spans cache-hit (lower) to cache-miss (upper) — two billing outcomes for the same tokens, not a ratio. Attribution uses per-model rates; a model the table does not carry resolves to the nearest named one where an alias exists, and falls back to Sonnet 4.5 otherwise. Only the fallback is reported as a substitution._
Analyzed 2026-09-16 with boxdawn 0.5.11, the build published on PyPI, in an isolated environment. The figures are identical to six decimals to the 0.5.0 run of 2026-08-20, the 0.5.3 re-check of 2026-08-27, and every report from 0.5.5 through 0.5.10. No figure has moved across that series, and this run is line-identical to the 0.5.10 one apart from the analyzed timestamp. Three lines other than that timestamp have changed earlier in the series: 0.5.8 added the line under the breakdown naming which four detectors the cost table covers and saying an absent row is not a measured zero, and 0.5.10 renamed the first of those four from provable_duplicate to repeat and had that line state that repeat is keyed provable_duplicate in the JSON report, which is why the dashboard still joins on the old key. Earlier in the series what changed was the report's formatting. Source: boxdawn analyze on davanstrien/agent-race-traces (claude-code.jsonl), a Claude Code session on claude-opus-4-7 published under CC-BY-4.0 ($2.524880 analyzed); that model is in our price table, so the dollar figures are not at a fallback rate. The trace is public, so every figure above can be reproduced. Shows Cost summary + Context resend sections; Redundant read and LLM-judge (opt-in) return empty on this specific trace.
Open source, because trust is the product.
Boxdawn is MIT-licensed and deterministic by default. Four detectors (repeat, context resend, redundant read, and duplicate creation) run locally with no API calls and no signup. A fifth layer, semantic-duplicate LLM-judge, is opt-in only: off by default, requires ANTHROPIC_API_KEY and explicit CLEW_ENABLE_LLM_JUDGE=1 to activate. Same trace in, same report out. Every time, for the deterministic layers.
$ pip install boxdawn$ boxdawn analyze your_trace.jsonWorks with OpenTelemetry SDK JSON and OpenInference trace exports: LangGraph, CrewAI, AutoGen, LlamaIndex. OTLP proto-JSON is not yet supported.
Where we are on the chain.
Boxdawn is a chain: monitor → detect → alert → auto-fix → auto-optimize + govern. Detection is the link that runs today, as a service and as a library. The rest is being built in that order, and this page is where you can check which is which.
- 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
- open-source CLI, runs offline
- opt-in semantic pass
- baseline alerts
- real-time monitoring
- loop detection
- visual session flow
- latency alongside cost
- auto-fix
- auto-optimize
- policy and governance