Just want the answer? pi has no cost hook to attach to — you have to move where the model traffic goes. Install the tool-call extension, then add a provider for the cost X-ray:
curl -sf https://agenticcontrolplane.com/install.sh | bash
# ~/.pi/agent/models.json
{
"providers": {
"acp": {
"baseUrl": "https://api.agenticcontrolplane.com/v1",
"api": "openai-completions",
"apiKey": "!cat ~/.acp/credentials",
"compat": { "supportsDeveloperRole": false, "supportsReasoningEffort": false },
"models": [{ "id": "gemini-3.5-flash" }]
}
}
}
# then: pi --model acp/gemini-3.5-flash
Full pi install guide → · pi's control model, explained → · free up to 5 agents
pi's minimalism is the whole design — four tools, no permission system, extend it yourself. That same minimalism means there's no cost hook to extend, either. The two typed events an extension gets, `tool_call` and `tool_result`, dispatch on *tools*: they see arguments and results, never a token count or a model's usage fields. There is no seam inside pi where an extension could intercept a model call the way it intercepts a tool call, because pi doesn't route model calls through its extension pipeline at all.
That makes pi's cost story different in kind from [Hermes's](/blog/hermes-cost-tracking), which has an in-process hook on every LLM request, and closer in shape to [Codex CLI's](/blog/codex-cli-cost-tracking): the only way to see what a call cost is to change where it goes.
## Why the extension can't do this
The [ACP extension for pi](/controls/pi) is genuinely comprehensive for what it covers — `tool_call` fires before every `bash`, `read`, `write`, `edit`, or custom tool call and can deny or rewrite it; `tool_result` fires after and can redact or rewrite what the model reads back. Because pi has no MCP layer and no second tool-dispatch path, that pair of events sees everything the agent *does*. It just never sees what the agent's model calls cost, because pi's core loop talks to the model provider directly, outside the extension pipeline both events are wired to.
So adding the extension gets you policy and an audit trail on tool calls — deny, ask, allow, redact — with nothing about spend. Cost needs a second, separate mechanism.
## The config
pi's model calls can route through the ACP proxy the same way any OpenAI-compatible client's can. Add a provider entry in `~/.pi/agent/models.json`:
```json
{
"providers": {
"acp": {
"baseUrl": "https://api.agenticcontrolplane.com/v1",
"api": "openai-completions",
"apiKey": "!cat ~/.acp/credentials",
"compat": { "supportsDeveloperRole": false, "supportsReasoningEffort": false },
"models": [{ "id": "gemini-3.5-flash" }]
}
}
}
```
Then launch pi against it:
```bash
pi --model acp/gemini-3.5-flash
```
The proxy is multi-provider — it routes `gpt-*`, `claude-*`, and `gemini-*` model ids to the matching upstream and forwards the request unchanged. Same response back; the difference is the usage fields on the way through get read and priced, and the call lands as a row joined to the tool-audit rows for the same session, in [the console](https://cloud.agenticcontrolplane.com).
## What you get once it's routed
Once a model in `models.json` points at the proxy, calling pi with `--model acp/...` gives you the same per-call cost picture documented for [turning on the cost X-ray](/cost-tracking) generally:
- **Per-call cost** — tokens in and out, priced to dollars, rolled up per run
- **Prompt-cache hit rate** — so a cold cache doesn't silently double a session's cost before anyone notices
- **The loop-vs-leaf split** — how much of the spend is the agent re-reading its own context to decide the next step, versus doing the work
- **A policy check on the tool calls the model emits** — the proxy sees the `tool_use` blocks in the model's response, which is a second, coarser layer than the extension's own `tool_call` interception, not a replacement for it
None of that shows up if pi is still pointed at its default provider. The extension and the provider entry are independent: you can run the extension alone (policy, no cost), the provider alone (cost, no tool-call policy), or both together, which is the configuration that gets you the full picture in one console.
## Budget limits
Once model traffic is routed through the proxy, **workspace-billed** traffic is subject to your workspace's daily LLM cost cap, enforced at the gateway before the call goes upstream — the session fails rather than runs up a bill past the limit. **Bring-your-own-key** traffic is billed by whichever provider you're calling; ACP meters it but can't cap an account it doesn't hold. Without the provider entry in `models.json`, there's no cap at all, because there's nothing in pi's path to enforce one.
## Troubleshooting
**I added the provider but see nothing in the console.** Check you actually launched with `--model acp/