Engage Pulse / MarTech Governance
What an MCP agent actually costs to run against Marketo
Per-task AI cost is not a function of how long a task takes. It is a function of how much context gets re-sent, how much raw Marketo JSON gets carried, and which model reads it. This model prices a real workload across all three budgets that constrain it — token spend, Marketo API quota, and seat capacity — and shows how much of the bill is a design decision rather than a usage decision.
Instance assumptions
Set these to the client’s actual environment. The tool-schema figure is the one people underestimate: every tool definition exposed by the MCP server is re-sent on every single request.
Governance levers
These three are the entire argument. None of them changes what the agent is asked to do — they change how the request is built. Toggle them to see the same workload repriced.
Task archetypes
Replace these with the client’s real tasks and measured turn counts. Turns is agent round trips; records is how many Marketo objects come back across the whole task. Both should be measured during a pilot, not guessed — see the metering protocol below.
| Task archetype | Turns | Records | Runs / mo | Manual min | Model tier | Tokens / run | Cost / run | API calls | Monthly | |
|---|---|---|---|---|---|---|---|---|---|---|
| Totals | ||||||||||
The three budgets
A workload can be affordable and still be unshippable. Token spend is the budget people ask about; API quota is the one that takes down the Salesforce sync at 4pm.
Where the money goes
The same workload, priced with each lever applied in turn. Each bar is what remains of the monthly bill after that lever is in place; the hatched section is what the lever removed.
Against the alternative
The comparison that ends the budget conversation is not agent cost versus zero. It is agent cost versus the loaded cost of the operator doing the same work by hand — with the build effort and the human review that agent output still requires both charged against it. Token spend is rarely the number that decides this.
Methodology and limits
Read this before putting a number in front of a budget owner. An estimate presented without its assumptions is a liability.
How each figure is calculated
Why cost is quadratic, not linear
An agent task is not one API request. It is a sequence of them, and each request carries everything that came before it: the system prompt, every tool schema, every prior assistant message, and every prior tool result. A six-turn task does not cost six times a one-turn task — it costs closer to fifteen times, because the payload compounds.
Here C is fixed at 550 tokens per exchange (assistant reasoning plus a small tool result) and output at 300 tokens per turn. A shaped Marketo person record is modelled at 45 tokens; an unshaped one, carrying the full custom-field set, at 420. That ratio is the entire response-shaping lever.
Pricing
Published Anthropic list rates per million tokens, as of August 2026. Cache writes use the 5-minute tier, modelled as one write per task and a read on every subsequent request — deliberately conservative, since back-to-back tasks inside the cache window would share a single write.
- Opus 5 — $5 in / $25 out / $6.25 cache write / $0.50 cache read
- Sonnet 5 — $2 in / $10 out / $2.50 cache write / $0.20 cache read
- Sonnet 4.6 — $3 in / $15 out / $3.75 cache write / $0.30 cache read
- Haiku 4.5 — $1 in / $5 out / $1.25 cache write / $0.10 cache read
Marketo API calls
One call per agent tool call, plus pagination: Lead Database endpoints return at most 300 records per call, so a 900-record pull is three calls regardless of how the agent asks for it. Access-token requests are assumed to be reused rather than re-issued per call — if the integration re-authenticates on every request, double the call count.
The instance limits that matter: 50,000 calls per day on most subscriptions, resetting at midnight CST; 100 calls per 20 seconds; 10 concurrent calls. All three are shared across every API service and user in the instance, not reserved for this integration.
What this model does not include
- Retries and failed runs. Add 10–20% to token spend until measured.
- Ongoing maintenance — schema drift, Marketo API changes, tool updates as the instance evolves
- The cost of a wrong action taken against production data. This is not a token cost, and it is the reason review percentage is an input rather than an assumption.
- Extended thinking budgets, if enabled — these can materially change output token counts
- Volume or committed-use discounts, and the 50% Batch API discount where work can run asynchronously
The metering protocol that replaces these estimates
Every number above is a starting assumption. Replace them inside two weeks:
- Pick 8–12 archetypes that cover the real request mix, weighted by frequency
- Run each three times against a sandbox instance, logging actual input, output, and cache-read tokens per request, plus Marketo call counts
- Record the spread, not just the mean — variance is what blows a budget
- Load the measured figures into this model and re-price
- Set a hard monthly ceiling with alerting at 60% and 85%, and a per-task turn limit so a looping agent cannot run away