Optimizing Cost & Context
Every Producer Pal conversation starts with a fixed overhead: the schemas for the tools your client can call, plus the skills that teach the AI how to use them. With everything switched on that's roughly 80,000 characters — about 20,000 tokens before you type a word.
You can cut that by more than half without giving up anything you actually use. Worth doing if you run a small or local model with a tight context window, if you pay per token, or if you only ever use part of Producer Pal.
What you're paying for
| Sent at the start of every conversation | Characters | Tokens |
|---|---|---|
| Tool schemas (the 21 default tools) | ~38,000 | ~9,500 |
| Skills | ~42,000 | ~10,500 |
| Total | ~80,000 | ~20,000 |
On top of that: your context and memory, however much you've written. Then per message, your prompt, the AI's reply, and the result of every tool call it makes.
Every figure on this page is in characters, with tokens alongside where it helps — converted at the usual rough estimate of 4 characters per token. Characters are what Producer Pal can actually count; tokens depend on the model's tokenizer. All measurements use the default bar|beat notation and standard skills, and your client wraps the schemas its own way, so treat them as ballpark.
Narrow the toolset
The biggest single win, because withholding a tool drops both its schema and the part of the skills that teaches it. Switch off the writing tools and the transform guide, the arrangement-writing guide, and the device-building guide go with them.
Schemas plus skills, measured against the default toolset:
| Toolset | Tools | Characters | Tokens | Saved |
|---|---|---|---|---|
| Default | 21 | ~80,000 | ~20,000 | — |
core,clip,track | 8 | ~47,000 | ~11,700 | 41% |
read-only | 8 | ~30,000 | ~7,600 | 62% |
Those two rows keep the same number of tools and save very different amounts: read-only wins because dropping every writer takes the whole write-side half of the skills with it.
Where you set it depends on the client — see Choosing a Toolset for the full list, or go straight to the Chat UI's Tools tab, the --tools flag, or the REST API's per-request header.
Toolset is per client, so narrowing your coding agent leaves the Chat UI alone.
Trim skills you don't need
For areas where you want to keep the tool but not the guidance — you use transforms, say, but never the generative ones. Every fragment has an Include checkbox in the Chat UI's Skills tab, and the guide has a table of what to switch off for each thing you never do.
Small model mode
Small model mode cuts both halves: the skills drop to a much shorter set, and advanced parameters come out of the tool schemas.
| All tools enabled | Standard | Small model mode |
|---|---|---|
| Schemas (characters) | ~38,000 | ~22,000 |
| Skills (characters) | ~42,000 | ~3,000 |
| Total (characters) | ~80,000 | ~25,000 |
| Total (tokens) | ~20,000 | ~6,400 |
That's 68% off, the largest single reduction available, and it stacks with a narrow toolset: read-only in small model mode comes to ~9,000 characters (~2,300 tokens), 89% off.
It isn't a pure cost lever, though. It exists to make local models viable, so it trades away capability — the advanced parameters are gone, and memory is off. Reach for it when the model needs it, not just to save tokens.
The device setting applies to the Chat UI and every connected client at once. A REST or MCP client can switch it on for just its own requests instead.
Notation
The notation guide is the one part of the skills that changes with the notation, and the three differ a lot:
| Notation | Notation guide (characters) | All skills (characters) | All skills (tokens) |
|---|---|---|---|
bar|beat | ~8,300 | ~42,000 | ~10,500 |
stark | ~3,500 | ~37,000 | ~9,300 |
midi-json | ~700 | ~34,000 | ~8,600 |
midi-json needs a twelfth of the guidance bar|beat does — it's a JSON array of note objects, so there's little to teach, and nothing extra for writing notes. Everything else in the skills is notation-neutral, so that gap is the whole difference between the two totals.
Still, pick for fit rather than size: the guide is a small slice of the ~80,000 characters a conversation starts with, and the notation decides how well your model actually writes music. midi-json for coding agents, stark for small models, bar|beat for conversation.
In small model mode the order changes — stark's basic guide is ~2,900 characters against bar|beat's ~1,400 characters — so the standing recommendation of stark for local models is about reliability, not size.
Keep responses compact
Tool results are a per-message cost, and they add up over a long session.
- Response format.
compactis a token-optimized literal and the default everywhere except the REST API, which defaults tojson— easier for scripts to parse, but larger. Keepcompactfor normal conversations. See--formatand the REST API's format option. - Read only what you need. The read tools take an
includelist — reading a track withoutnotesordevicesis dramatically smaller thaninclude: ["*"]. Ask for a specific track or clip rather than the whole Live Set when you know where you're going.
Watch your context and memory
Project context, global context, and memory are sent every conversation, so they're a standing cost like the skills. The context editor shows a character and token count for each one — useful when a global context you wrote months ago has quietly grown. Keep them to what changes the AI's behavior.
How to measure
- Skills tab → Preview in the Chat UI assembles the exact skills document for any notation and model size, with your overrides and toolset applied, and gives its size in characters and estimated tokens. A ★ marks the combination your current settings use.
- Show message token usage in Preferences prints input, output, and reasoning tokens under every response. See Token Usage.
npx producer-pal --list-toolsconfirms which tools a client is actually getting. See the CLI reference.