YOUR AGENT'S TOKENS COST REAL MONEY

Stop paying for
tokens it doesn't need.

Every token your agent uses shows up on your bill. Most agents burn far more than the task needs.

  1. 01 — See it. The free Auditor measures exactly how many tokens — and dollars — your agent wastes.
  2. 02 — Fix it. The Optimiser cuts that waste with drop-in tools. Same agent, same model, fewer tokens.

Find savings across reads, edits, searches, tool menus, and unnecessary calls—not just repeated work.

Audit my agent — free Watch an agent run
Local-firstZero runtime dependenciesNo account
CONTEXT OBSERVATORY
YOUR AGENT context, layer by layer
Avoidable work, revealed.
Find opportunities across the run.

The Auditor shows where tokens go and estimates opportunities in tool payloads, menus, and calls. It observes your agent; it does not change it.

Interactive concept illustration · not live telemetry or a savings prediction

MEET YOUR AGENT WHERE IT WORKS
LangGraphCrewAIAutoGenOpenAI Agents SDK

THE AGENT, OPENED UP

Go beneath
the next token.

96-SECOND GUIDED LOOP

Pull the layers apart. Follow a request through the engine. See where the Optimiser changes the work—and how the Auditor watches without taking the wheel.

Agent executionOptimiser interventionAuditor observation
ILLUSTRATIVE TASK / UPDATE A CONFIG VALUE01 / ATTACH

Scroll the diagram sideways to inspect every layer.

Attach observation hooks before the run.

CHAPTER 01 / 08

A sensor, not a detour.

Your agent

Your existing framework owns the task, model client, and tools.

Optimiser / changes execution

Replacement tools are wired separately. Installing the Auditor does not enable optimisation.

Auditor / observes execution

Attach framework callbacks, event listeners, a trace processor, or explicit client/tool wrappers before execution.

This rail represents in-process instrumentation, not a proxy between your agent and its model.

Animated explanation, not a recorded run. Sequence, gear motion, payload shapes, and timing are illustrative. Real agents branch, fail, retry, and make different numbers of turns. No fixed token reduction is implied.

Read the complete lifecycle and attachment details

LangGraph / LangChain

Pass AuditorCallback through the invocation's config["callbacks"]. Finish the handler when the run ends.

CrewAI

attach() subscribes to the framework's event bus. Detach after execution.

OpenAI Agents SDK

attach() registers a tracing processor for supported model and tool spans. Tracing must be enabled; detach after execution.

AutoGen

Use wrap_client() for model usage and audit_tool() for tool I/O. Client wrapping alone cannot see tool execution. Finish the session after the run.

See the framework integration snippets

  1. A sensor, not a detour.

    Your existing framework owns the task, model client, and tools.

    Replacement tools are wired separately. Installing the Auditor does not enable optimisation.

    Original tools stay in place. The Auditor can observe this baseline without the Optimiser.

    Attach framework callbacks, event listeners, a trace processor, or explicit client/tool wrappers before execution.

    This rail represents in-process instrumentation, not a proxy between your agent and its model.

    1. Attach observation hooks before the run.
    2. Connect model and tool observations to one audit session.
    3. Keep the model endpoint and task under your framework's control.

  2. A smaller menu. The same objective.

    The framework assembles instructions, conversation history, and tool schemas into a model request.

    A configured tool profile offers task-relevant tools with concise descriptions. Instructions and history are not rewritten.

    The original tool list and descriptions travel with the request, whether or not every tool is needed.

    The audit session is ready for exposed events. It does not prune the request or decide which tools the model sees.

    Tool profiles require configuration; the Optimiser does not automatically discover the perfect tool set.

    1. Keep the goal and instructions intact.
    2. Offer a configured tool menu suited to the task.
    3. Send the request to the existing model endpoint.

  3. The model still does the thinking.

    The model generates a response. It may request a tool, answer directly, or need another turn.

    No intervention inside inference. Savings come from supported tool surfaces, not changing model weights or reading hidden reasoning.

    Inference uses the same model endpoint. Its response and usage depend on the request and workload.

    On exposed model-completion events, the adapter normalizes provider-reported input and output usage into the session.

    Usage visibility depends on the SDK and provider. Missing usage is not proof that a model call was free.

    1. The model receives the assembled context.
    2. A response can contain a tool call or a final answer.
    3. The adapter records usage exposed by the integration.

  4. Find the useful part first.

    A tool call looks for the configuration value. The result becomes evidence for the next decision.

    Supported reads return useful structure; grouped, bounded searches return focused matches. Full reads remain available when needed.

    Broad reads and unbounded search output can return much more text than the next decision needs.

    Tool hooks capture the exposed name, arguments, and result. These observations support the local trace and supported shadow estimates.

    A bounded search is not complete coverage. Unsupported formats or missing context may need a fuller read.

    1. Dispatch the requested read or search.
    2. Return useful structure or a bounded set of matches.
    3. Observe tool I/O without replacing the result.

  5. Change a fragment, not a file.

    The agent wants to change a config value, such as a timeout from 30 to 45.

    An anchored edit replaces the exact matching region under a file lock and returns a short change confirmation.

    A full-file write asks the model to reproduce unchanged content alongside the actual modification.

    The adapter records exposed edit arguments and results. It observes the operation; it does not perform or approve the write.

    Ambiguous anchors must be resolved, not guessed. Application-level correctness still needs validation.

    1. Describe the relevant old and new text.
    2. Match safely, then apply the scoped change.
    3. Return a concise confirmation and observe the tool result.

  6. Do not execute known work blindly.

    A later call may repeat a read or ask to confirm an already confirmed write.

    When session guards are configured and the call is eligible, return a compact duplicate or post-write confirmation instead of repeating the underlying operation.

    The original tool can perform the read again and return its payload, even when recent work already answered it.

    Captured text passes through default secret-pattern redaction before persistence. The agent's actual tool result is not redacted by this capture path.

    Guards have state and eligibility limits. Suppressing tool execution does not erase the model turn that requested it. Redaction is not a guarantee that all secrets are removed.

    1. Check whether a repeated operation is eligible for a guard.
    2. Return a compact confirmation or execute when fresh work is needed.
    3. Redact captured text, not the agent's working result.

  7. A leaner result travels forward.

    Tool results return to the conversation. The framework can call the model again with prior context.

    Smaller tool payloads can reduce context carried into later requests. This is not automatic conversation compression.

    Large results can travel through later turns, adding replay overhead even when no tool call is duplicated.

    Normalized observations are appended to local events.jsonl; session metadata makes the run discoverable by the local dashboard.

    Context retention, caching, output prices, and later agent choices affect the outcome. There is no fixed savings multiplier.

    1. Append the tool result to the conversation.
    2. Prepare another model request if the task needs one.
    3. Persist observations locally as execution continues.

  8. Inspect the run. Separate fact from estimate.

    The run finishes or fails. Your application must judge whether the requested outcome is actually correct.

    Judge the changed tool behavior with real task checks and comparable runs—not with the animation's smaller shapes.

    A baseline trace can reveal candidate savings before you replace tools or change the workflow.

    Finish or detach to flush remaining observations. The local report shows captured usage and tool activity separately from shadow estimates of supported savings opportunities.

    Shadow analysis does not rerun the agent or make extra model calls. It is not a measured Optimiser outcome or a promised bill reduction.

    1. Finish the session and flush trailing tool observations.
    2. Inspect usage, tool activity, and available local estimates.
    3. Validate the task outcome and measure changes on your workload.

SEE THE COST. THEN CUT IT.

First, see it.
Then, change it.

Diagnosis and treatment are different jobs.
You should not have to buy both to try either.

01FREE · NO EXPIRY

THE AGENT AUDITOR

A lens, not a leash.

Turn a running agent into a readable story: tokens, tool calls, and where avoidable work may be hiding.

  • Capture usage through your framework’s hooks.
  • Explore runs in a local, live-updating dashboard.
  • Keep measured usage separate from estimated savings.
What does it actually do?

Attach the adapter to your existing agent, run it, then inspect the trace. The Auditor records observations and estimates what supported tool changes might save. It does not rewrite your prompts, choose a model, or prove a future bill reduction.

Captures stay on your machine. Secret-pattern redaction is enabled by default, but it is not a guarantee that all sensitive content is removed.

Start with the free Auditor
0290-DAY FREE TRIAL

THE CONTEXTOS OPTIMISER

Fewer tokens. Same goal.

Replace wasteful file tools with a focused tool layer. Keep your agent and model; change how the work gets done.

  • Edit the relevant part, not the entire file.
  • Find the answer without returning the whole document.
  • Reduce repeat calls and oversized tool menus.
What changes in my agent?

You wire replacement tools into your existing tool list. The Optimiser changes tool behavior and output, not the model endpoint. Validate task quality and savings on your own workloads; not every task or framework benefits equally.

After the 90-day trial, gated tool calls require a license. Imports and ungated functionality remain available. Nothing deletes or uploads your files.

Explore the Optimiser

MORE THAN DUPLICATE DETECTION

Not one trick.
A leaner way to work.

Useful work can still use fewer tokens. Explore five supported levers—from the size of a single tool result to the number of calls an agent makes.

INSIDE THE OPTIMISEREXPLORE A LEVER

A small change should not need a full rewrite.

Anchored edits can replace a small region instead of asking the model to emit the entire updated file.

The edit must match safely. Ambiguous changes need more context, not a blind replacement.

Schematic comparison—not a token scale or a savings forecast. Gains vary by task, content, model, and framework.

WHY THE SAVINGS CAN COMPOUND

Smaller payloads.
Less overhead
down the line.

Many tool-calling loops carry earlier context into later turns. A smaller tool result can reduce what gets carried forward; an avoided call can remove a whole round-trip.

This is one part of the story—not a fixed multiplier. Context reuse, caching, output pricing, and the agent’s behavior all affect the outcome.

See how that played out
CONTEXT REPLAYTRY THE SLIDER
Replayed contextNew context
21context units processed
15 replayed + 6 new

Illustration: one equal-sized chunk added per turn. Units are not tokens or dollars; caching and output pricing are excluded.

THE EVIDENCE, WITH THE EDGES LEFT IN

Show the wins.
Keep the caveats.

Explore the same seven tasks across four frameworks. These are historical live-run measurements—not promises for your next run.

LANGGRAPH
53.4%

lower token cost
across the benchmark tasks

HISTORICAL SNAPSHOT / AUG 2026

‡ Raw-token result uncertain. Full caveats and methodology below.

gpt-5-mini7 domainsN=15 per arm / domainOutput weighted 8× input

Measured on an earlier build of the code; a fresh re-run is pending. These numbers use list token prices, not your actual bill, and are not a statistical guarantee.

Open the full matrix and methodology 28 measured cells. Nothing filtered out.
Historical cost-weighted savings (%) · source: live-results-2026-08-30.md
DomainAutoGenCrewAILangGraphOpenAI Agents SDK
Call centre ticket65.8%61.5%63.8%‡66.7%
Code bugfix51.0%48.5%‡51.9%‡53.7%
CRM update51.5%‡36.7%‡51.4%‡50.3%‡
DevOps log triage22.1%27.8%27.2%‡37.0%
E-commerce support28.5%‡1.7%21.9%‡23.5%‡
IT helpdesk config64.3%42.1%59.9%‡66.2%
Legal clause lookup70.9%58.7%69.9%‡74.8%

What the metric means

We count prompt tokens plus completion tokens (completion tokens weighted 8× to reflect their higher list price), comparing a baseline run against an Optimiser run. This is a token-price ratio, not a real subscription bill. It's a separate calculation from the Auditor's own on-your-machine estimates.

Where the uncertainty is

‡ means the raw token counts for baseline vs. Optimiser overlapped — so while the cost-weighted result favors the Optimiser, we can't yet call it a clean win on token count alone. LangGraph's ranges come from repeated real runs; other frameworks use a standard statistical interval. Either way, one summary percentage doesn't capture that range — see the full table above for the spread.

A result that did not win

CrewAI's e-commerce task actually used 20% more raw tokens with the Optimiser. Its cost-weighted saving was still positive (1.7%) only because of how output tokens are priced — a reminder that smaller edits don't automatically mean cheaper, once every call is counted.

What was actually checked

We verified each run's real file/state changes ourselves, rather than trusting the framework's own "success" flag. This table is a preserved historical snapshot; re-running it against the current codebase is still pending.

YOUR TRACE. YOUR MACHINE. YOUR ANSWER.

Start with
one real run.

Install in your agent’s Python environment. Attach its framework adapter. Open the local dashboard.

No hosted account. No telemetry.

The Auditor observes your existing run; it does not make extra model calls.

Just exploring? No agent required.

Install contextos-auditor, then run contextos-auditor demo to see a sample report. The demo is synthetic, not evidence about your workload.

01 / INSTALL
pip install contextos-auditor
02 / ATTACH TO YOUR EXISTING AGENT
from contextos_auditor.crewai import attach

audit = attach(task="my agent run")
try:
    crew.kickoff()
finally:
    audit.detach()
03 / OPEN THE LOCAL DASHBOARD
contextos-auditor watch --serve

Requires Python 3.10+. Your framework SDK must already be installed. Use a virtual environment if system Python is managed.

SIMPLE START. NO SURPRISE EXPIRY.

Free to understand.
A trial to improve.

Auditor

Free / no expiry

Commercial use included under PolyForm Shield. Competing products are restricted.

Start free ↗

Optimiser

90 days / free trial

No card to start. Gated tool calls require a license after expiry. Paid pricing is agreed directly.

Talk to the builder ↗

LESS GUESSING. MORE UNDERSTANDING.

Meet the work
behind the bill.

Get the free Auditor

Find the opportunity before changing your agent.