Quick Answer
model-right-sizer-schema is a Claude Code skill that designs the typed contract between one agent and the controller that dispatches it. Point it at an agent plus its controller and it returns a JSON prescription with typed in/out fields, an exclusion list that keeps raw logs out of the reply, a before/after size delta, then writes the contract into the agent's own file. It picks from nine portable output-shape families, or your repo's own.
The last thing I told a test agent before I let it loose on a repo was this: “write up your findings in a clear report… include relevant log excerpts.” I wrote that sentence in about four seconds, felt good about it, and moved on. It is also, on inspection, the single most expensive line in the file.
TL;DR
- Anthropic’s own engineering team found multi-agent systems burn roughly 15x more tokens than a single chat interaction, and that token usage alone explains about 80% of the variance in agent evaluation performance. What agents say to each other is most of the bill.
- Typed agent-to-agent contracts are old news; everybody already agrees they matter. The gap is that nobody hands you a verdict-set to start from, so every seam becomes a bespoke design exercise nobody has time for.
model-right-sizer-schemais a new companion skill in the CloudZero Claude Code marketplace. Point it at one agent plus the controller that calls it. It returns a typed schema prescription (fields, exclusions, a size delta) and writes the contract into the agent’s file.- It picks from a portable catalogue of 9 output-shape families (
scored-review,verdict-set,graded-claim,build-report,drafted-unit,data-payload,watch-report,action-log,candidate-set), or from your own repo’s catalogue if you already have one. - Install:
/plugin marketplace add cloudzero/cloudzero-claude-marketplace, then/plugin install model-right-sizer@cloudzero. Apache-2.0.
Five-step flow from a vague reply instruction to a stamped contract in the agent file.
Report
Finance needs to prove AI’s return: CloudZero report
260 senior finance leaders (more than half CFOs) told us why the speed of seeing AI spend, not the size of it, separates who pulls ahead on AI from who gets burned.
Why does a vague reply instruction cost so much?
Start with the number, because the number is not mine and not arguable. In How we built our multi-agent research system, Anthropic reported that multi-agent systems use about 15x more tokens than a single chat interaction, and that token usage by itself accounts for roughly 80% of the variance in agent evaluation performance.
Sit with the second half of that. The dominant explanatory variable in how well these systems perform is how many tokens they move, ahead of model choice and ahead of prompt craft and in a multi-agent chain. A huge share of that volume is agents talking to each other.
So “write up your findings in a clear report. Include relevant log excerpts” isn’t a friendly instruction. It’s an open invoice. It tells the sub-agent to produce prose of unbounded length, and it tells it to inline raw log text whose size scales with how bad the failure was. The worse the day, the bigger the handoff, at exactly the moment you can least afford it.
The tempting version of this post is “nobody designs the reply shape up front,” and that’s just not true anymore. Typed inter-agent contracts are conventional wisdom in 2026. Structured outputs, JSON mode, schema-validated tool calls: all standard. If I opened with “nobody’s thought of this,” every practitioner reading would close the tab, correctly.
The honest gap is smaller and more annoying than that. Two pieces of it:
- There’s no reusable, minimal, portable set of shapes to choose from. So designing a contract means inventing one from scratch, per seam, per agent, every time. That’s a 40-minute design exercise disguised as a five-minute chore, which is why it keeps getting skipped.
- Almost no tooling writes the contract into the agent’s own file for you. Structured-output APIs (the Claude Agent SDK’s output_format, Pydantic AI’s output_type) let you declare a schema, but you still write that declaration yourself, by hand, in code. None of them look at an existing agent, work out what its controller needs, and stamp the contract in. The agent file itself still says “write up your findings in a clear report.”
A controller dispatching a sub-agent, forking at the seam into unbounded prose versus a typed reply.
What does the skill actually do?
model-right-sizer-schema takes the model-right-sizer agent’s third lever; the agent-to-agent message-schema design; and applies it to exactly one seam: a single agent, the controller that dispatches it, and the message that passes between them.
That narrowness is the design. Its siblings work at different altitudes: model-right-sizer-dryrun maps a whole intent into a routing blueprint before you build anything, and model-right-sizer-install stamps a standing mandate onto a repo so every substantive task consults the right-sizer. This new one is deliberately the smallest lever in the set. You bring one agent and the controller that dispatches it, plus what that controller actually needs back. It gives you a contract.
You get a schema-conformant JSON prescription (validated against schemas/agent-schema.schema.json) with four parts that matter:
- Typed in and out fields: named, with types, and large payloads pushed behind context_ref state keys instead of inlined.
- An exclusion list: the things this agent must never send back inline. This is the part that kills the log excerpts.
- A size delta (savings_note): before and after, stated concretely, so the change is arguable rather than vibes.
- A ready-to-insert ## Agent-to-agent schema markdown stamp: which the skill writes directly into the target agent’s file.
The family catalogue is what makes it fast. If your repo already has its own schema families, it uses yours. If it doesn’t, it falls back to a portable one that ships with the skill: schemas/agent-schema-families.md, nine families covering the shapes agents actually return. A reviewer agent returns a scored-review. A test triager returns a verdict-set. A writer returns a drafted-unit. The work stops being design and becomes recognition. You already knew what shape the agent’s reply had. You just didn’t have a name to reach for.
Three inputs feed a catalogue decision, then a JSON prescription, then a stamp written into the agent file.
Takeaway: Most tooling hands you a recommendation and leaves the implementing to you. This one opens the agent file and writes the contract in.
What happened when we ran it on a throwaway agent?
I wrote a deliberately bad test agent called flaky-test-finder. Its only output instruction was the sentence at the top of this post. Then I ran the skill against it, with a named controller: a ci-triage skill with four needs and no others. That’s a per-test verdict, a jump-to location, a signal that says “nothing flaky here, don’t alert anyone,” and somewhere to put the failures it couldn’t call either way.
The prescription came back as a verdict-set: four typed fields (scope, rows, gate, unresolved) plus one bounded prose slot capped at 80 words. Every one of the controller’s four needs has exactly one place to land. rows carries the verdict and the file location per test. gate carries the don’t-alert signal. unresolved catches the failures the agent couldn’t adjudicate, which is the need that most often gets dumped into a paragraph instead. scope says what was actually covered. That’s the replacement for a report the agent’s own baseline estimate put at 600 to 1,200 words, with log excerpts growing alongside the failure count.
Before and after: unbounded prose versus a verdict-set of four fields plus a capped prose slot.
Takeaway: Four fields and one bounded prose slot replaced a report nobody was going to read end to end anyway.
How do you right-size one seam yourself?
Five steps. The controller is the decision-maker throughout. Every one of them is sized to what it needs, not to what the agent finds interesting to report.
Step 1: Install the plugin
Run /plugin marketplace add cloudzero/cloudzero-claude-marketplace, then /plugin install model-right-sizer@cloudzero.
Step 2: Name the controller, not just the agent
Choose one agent and name the controller that dispatches it. If you can’t name the controller, you’re not ready. That’s the input that determines everything downstream.
Step 3: Write down what the controller actually consumes
Every field it reads, and nothing it merely finds interesting. For our ci-triage case that was four things: verdict, location, skip-alerting signal, and a bucket for anything the agent couldn’t call either way. Being stingy here is the whole point.
Step 4: Run the skill and read the prescription
You get typed fields, an exclusion list, a chosen family, and a before/after size delta. Check the family choice against your own understanding of what the agent returns. The skill validates this now, but you should still eyeball it.
Step 5: Let it write the stamp, then verify the file
The skill inserts the ## Agent-to-agent schema block into the target agent’s file. Open the file. Confirm it landed. This is the step that separates a real change from a good conversation.
What does the agent hand back? A two-column mapping from output kind to schema family.
Try it on one seam of yours
model-right-sizer-schema is a new companion skill in the CloudZero Claude Code marketplace. Install it, point it at one agent that still hands its controller a wall of prose, and see what family it picks.
Get it:
- cloudzero/cloudzero-claude-marketplace: the plugin, Apache-2.0
- CloudZero AI Model Right Sizer docs
- PR #40: the change itself, if you want to follow along or see the review history
Background reading:
- How to right-size your existing skills: the sibling skill announcement, and the other half of this series. Not linked here because it isn’t live yet; it publishes alongside this one, and if you’ve been following the series you’ve likely already read it.
- Model Rightsizer
- Model Rightsizer: the engineering post
- Anthropic — How we built our multi-agent research system: source of the 15x / 80% figures
