Monitoring cost

Watcher grades your coding agents' work with paid model calls. Apollo Research's published estimate puts their cost at 3 to 5% on top of what the agents themselves spend. Your share can be higher, for example when your agents use a cheaper model. Treat the figures on this page as a starting point, and measure your own cost before a wide rollout.

Dollar figures on this page are model providers' list prices. A self-hosted deployment pays them to its providers. On Watcher Cloud you get no provider bill for grading. Instead, a monthly grading limit can cap your organization's use.

Where the cost comes from

Each time a grader reviews something, Watcher makes a paid model call. Graders run at three points.

Before a tool call runs. Blocking review decides whether a call may go ahead. The agent waits for the answer, so the checks run from cheapest to most expensive, and stop as soon as one decides:

1. Command rules and tool thresholds match the call against your fixed rules and settings. No model runs, so they cost nothing. By default, read-only tools such as file reads and searches are always allowed this way.
2. Triage asks a small, fast model to score the call. It costs a fraction of a cent, about $0.002 a call. A low score lets the call through; anything else goes on to gateway review.
3. Gateway review asks a large model to judge the call against the conversation so far. It costs roughly $0.40 a call, and more late in a long session. This step makes up most of the grading cost.

After tool calls run. Trailing review grades sessions on the server without holding up the agent:

• Summaries give each session a title and short description. A small model writes them, usually at under a cent each, at most every 15 minutes while a session is active.
• Deep Review takes a second, thorough look at a session once gateway review has scored one of its calls 7 or higher, or when a user requests one. Each costs roughly $0.50. Few sessions qualify, and the automatic review runs at most once a day per session.

Trailing review typically adds a few percent to the cost of blocking review.

On request. Custom graders run only when you call them through the API or SDK.

The published estimate

Apollo Research measured blocking review on 7,500 tool calls from its own coding sessions, using the default managed monitors at the time. The Watcher Live announcement (September 2026) reports:

• Grading cost 3 to 5% on top of what the coding agent itself spent.
• Waiting for grading added 6 to 8% to the agent's working time.
• Command rules and tool thresholds decided about 55% of tool calls.
• About 6% of tool calls went on to gateway review.

The estimate covers blocking review only, at September 2026 model prices.

What changes your share

Grading cost follows how many tool calls your agents make and how long their sessions run. It does not follow what the agent itself costs. As a rough guide, blocking review costs about $2.50 per 100 tool calls. Your share of agent spend then depends on:

• The agent's own model. An agent on a cheaper model spends less per tool call while grading costs the same, so grading is a larger share: 10% of agent spend or more on lower-priced frontier models.
• Session length. Gateway review reads the conversation so far, so late calls in a long session cost more to grade.
• Tool thresholds. Triage approves a call only when its score is below the tool's flag and deny thresholds. Lower thresholds send more calls to gateway review.
• Subagents. Their tool calls are graded too when they reach blocking review, so they add to the call count. See Subagent coverage.
• Monitor models. A self-hosted deployment can change them. See Self-hosted deployments.

Worked examples

The inputs below are illustrative.

One session

A two-hour session makes 300 tool calls:

Stage	Tool calls	Grading cost
Decided by rules and thresholds (55%)	165	$0
Scored by triage	135	about $0.30
Of those, sent on to gateway review (6% of all calls)	18	about $7.20
Total	300	about $7.50

If the agent spent $190 on this session, grading adds 4%. If it spent $75, as an agent on a cheaper model might, grading adds 10%. On Watcher Cloud, the same session uses about 27 grader calls: 18 gateway reviews and about 9 summaries.

This is a busy session, with 150 tool calls an hour and about $3.75 an hour of grading. Over a working day, a typical agent makes far fewer tool calls, because it waits on its developer.

A team over time

These examples assume agents run 6 hours a working day, 5 days a week and 20 days a month. Each grading cell shows grading at 4% and at 10% of agent spend.

Team	Agent spend per hour	Grading per hour	Grading per day	Grading per week	Grading per month
10 engineers, each running one agent at $10 an hour	$100	$4 to $10	$24 to $60	$120 to $300	$480 to $1,200
100 engineers, each running one agent at $10 an hour	$1,000	$40 to $100	$240 to $600	$1,200 to $3,000	$4,800 to $12,000
100 engineers, each running parallel agents that total $25 an hour	$2,500	$100 to $250	$600 to $1,500	$3,000 to $7,500	$12,000 to $30,000

Grading cost arrives only while agents work, so a peak hourly rate looks high next to the monthly total. On the schedule above, $100 an hour of grading comes to about $12,000 a month if that rate holds through the working day. It is also what about 27 agents as busy as the session above cost when they run at the same time. Scheduled or CI agents that run outside working hours add to these totals.

Measure and control your cost

Before a wide rollout, run Watcher in observe mode, one of the enforcement modes, for a day with a representative group of developers. Observe mode grades calls much as enforce mode does, so its cost is a fair guide. Agents do not wait in observe mode, so the trial shows cost but not the added wait. Then scale that day's cost up to your whole team and to a month of working days, as the team table does.

The Analyzer's Model Usage page shows which models ran and how many calls went to trailing review, triage and gateway review. Admins can read it by default. Multiplying its call counts by the rough per-call costs above gives a dollar estimate on either deployment. Its breakdown by grader separates summaries from deep reviews.

To stop blocking review's model calls at once, switch to paused enforcement mode. Paused also turns off command rules and tool thresholds, so nothing is enforced. Trailing review keeps running.

Self-hosted deployments

Your deployment calls the model providers with your own API keys, and you pay them directly. Your provider invoice is the authoritative figure.

• Read the estimate. Model Usage also shows an estimated cost at the model prices set on your deployment. If you pay negotiated rates, set them under model_pricing in your server configuration so the estimate tracks your invoice. Compare the estimate with your coding agents' own bill for the same day to get your share of agent spend.
• Watch the provider bill. Give Watcher its own provider API keys, so a limit on them does not also stop your coding agents. The default monitors use more than one provider, so set a budget alert on each key and check how much of it a day of grading uses. Prefer alerts to hard limits:
  • A hard limit on the gateway monitor's key makes gateway review fail. Every call that triage does not approve then takes Watcher's failure decision until the limit resets. That decision is escalate, deny, or allow. The default, escalate, sends each call to the developer's permission prompt, and a non-interactive run such as claude -p denies it.
  • A hard limit on the triage monitor's key alone raises cost: calls that triage cannot score all go to gateway review instead.
  • Observe mode does not affect agents in either case.
• Tune the monitors. The monitors section of your server configuration can set a cheaper model for a monitor role, such as triage or gateway. A different model changes what Watcher catches, so try a change in observe mode first. Under the triage role, triage_escalation_threshold sets the score at which triage stops approving calls on its own, 8 by default. Triage approves only scores below both this value and the tool's thresholds, so a change has an effect only where this value is the lower one. Lowering it there sends more calls to gateway review and raises cost.

server-config.example.yaml in the self-host bundle documents model_pricing and monitors. With Docker Compose, mount your server-config.yaml into both xylon-api and xylon-operation-worker, as compose.override.yml.example shows, and recreate both after a change: docker compose up -d --force-recreate xylon-api xylon-operation-worker. For Kubernetes, see Helm server configuration.

Watcher Cloud

Watcher makes the model calls, so Model Usage shows call counts rather than cost. If your organization has a monthly grading limit, admins see Grader calls this month against it on Model Usage. That count includes gateway reviews, trailing reviews and grades you request through the API. The limit also covers triage and failed grades, and it accounts for what each call costs, so grading can pause well before the count reaches it. Watcher Cloud shows no other measure of your use against the limit, and gives no warning before a pause. Treat the count as a lower bound. If a pause in enforce mode is not acceptable during a pilot, run the pilot in observe mode, where a pause does not affect agents.

When the limit is reached, grading pauses until the limit resets at midnight UTC on the 1st of the month, and the Analyzer shows a Grading paused banner with the date grading resumes. Triage stops too, so every call that command rules and tool thresholds do not decide takes the failure decision until then. That decision is escalate, deny, or allow. The default, escalate, sends each call to the developer's permission prompt, and a non-interactive run such as claude -p denies it. Trailing review stops until then too.

Per-call cost from gateway hooks

If you integrate through gateway hooks, each response carries cost_usd: the estimated cost of that call's triage and gateway review, at the prices set on the server.