When Meta shipped Muse Spark 1.3 on September 2, 2026, the line that stuck with me wasn't the coding benchmark. Chief AI officer Alexandr Wang framed it as their strongest model yet, on par with Claude Fable 5.1 and ahead of GPT-5.6 Sol on coding. Fine. The number I actually cared about was buried in the release blog: compared to Muse Spark 1.2, the new version supposedly makes about 20% fewer tool calls and needs roughly 25% fewer tokens to finish the same task.
Those are vendor figures, and I'll say it plainly: unverified. I have no idea what "the same task" meant in their harness, or how they counted a tool call. But the claim is interesting precisely because it's the kind of thing you can't take on faith and shouldn't have to. If a model is going to be cheaper per task, that shows up in your own logs or it doesn't show up at all.
So instead of arguing about the spec sheet, I built a small agent whose entire job is to prove or disprove efficiency claims on my own workload. This is a debrief on how it came together, what broke, and where the platform boundaries actually sat.
Why efficiency is an observability problem, not a marketing claim
The pricing is what makes this worth measuring. Muse Spark 1.3 kept the same rates as 1.2: $1.25 per million input tokens, $0.15 per million on cache-hit input, and $4.25 per million output tokens. Output is more than three times the price of input, which tells you where the money leaks. A chatty agent that re-explains its plan on every turn, or re-calls a tool it already called, burns output tokens you can't get back.
For contrast, Multiverse Computing's Quasar 438B lists $0.60 per million input and $1.80 per million output. Different model, different tier, but the shape of the problem is identical: your bill is a function of how many calls you make and how much text you generate, not the headline number in a launch post. A model that's "25% more efficient" on someone else's eval can still be more expensive on yours if your prompts trigger more retries.
That's why I treat token and call efficiency as instrumentation. You don't trust it, you count it. And counting it means every tool invocation the agent makes has to leave a record you can query later.
The build: a Python loop that narrates itself into a table
The core is unglamorous. Most of the real leverage in AI agent development comes from the plumbing around the model, not the model itself, and this project is mostly plumbing.
I wrote the agent loop as a Python backend, since VicroCode lets me run Python online without standing up my own server. The loop does the boring, essential thing: before it dispatches any tool, it writes a row; after the tool returns, it updates that row with the result size and outcome. The model never touches the ledger. The wrapper does, because the wrapper is the only thing that actually knows a call happened.
Each row captures the run ID, the step index, which tool was requested, the arguments, a timestamp, input and output token estimates for that step, and a status. I intentionally logged the request before execution so that a crash mid-call still leaves a trace. Silent failures are the enemy of any efficiency claim, because a retried call that isn't recorded makes the model look cheaper than it is.
Those rows land in a SQLite database, which is the part I'd underrate if I were describing this to someone in a hurry. SQLite is enough here precisely because the workload is one agent, many small writes, and lots of after-the-fact reads. When I needed to eyeball a run that went sideways, the in-platform SQLite editor let me open the table and scan the sequence of calls without exporting anything or writing throwaway scripts. Half my debugging was just reading the ledger top to bottom and asking why step 7 repeated step 4.
Confirmation gates, because the model asking nicely isn't a control
One of Muse Spark 1.3's advertised behaviors is that it asks clarifying questions on vague instructions, requests help when it hits a wall, and seeks confirmation before critical operations. Good instincts, if true. But "the model tends to ask first" is a behavior, not a guarantee, and I'm not going to let a probabilistic system decide on its own whether a step is expensive enough to pause on.
So the gate lives in my code, not in the prompt. Before any step I've tagged as costly — a long generation, a batch operation, anything that would spike output tokens — the backend halts and surfaces a confirmation to me with the projected cost pulled straight from the ledger's running totals. The model can suggest. The gate decides. This separation matters: if the vendor changes the model's default behavior in a future version, my spending controls don't move.
The practical payoff showed up on the first real run. The agent wanted to regenerate a full document after a tiny edit request. The gate caught it, showed me the token estimate, and I declined. That single stop probably saved more than a day of the model "being efficient" on its own.
What the ledger actually told me
Here's the honest part. I can't confirm Meta's 20% and 25% because I never ran a clean head-to-head against 1.2 on identical tasks — that would need a controlled harness I haven't built, and I won't pretend a few ad hoc runs count. What the ledger did give me was something more useful day to day: a per-run cost I could trust, a clear picture of which tools got called redundantly, and a way to spot when a prompt change made things worse.
That reframes the whole model-shopping question. When Quasar 438B or the next Muse Spark drops, I don't have to believe anyone's efficiency story. I point the same agent at whatever's available through the platform's Model Center, run my real tasks, and read the table. The ledger is model-agnostic on purpose.
Where the boundaries sat
A few honest limits, since a debrief that only lists wins isn't a debrief.
This setup measures models the platform already exposes through its Model Center APIs. If a model isn't available there — and plenty in the evidence, like the ones behind Meta's own API or CompactifAI, are accessed through their vendors' endpoints — this agent can't call it directly. My ledger measures what I can actually run, not the entire market.
The token counts in my rows are estimates unless a given API returns exact usage. I labeled the column as an estimate for exactly that reason, and I'd rather show an honest approximation than a precise-looking number I can't back up.
And SQLite is the right tool because this is a single-agent, moderate-volume workload. If you were fanning this out across many concurrent agents hammering the same file, you'd feel the write contention and want to rethink the storage layer. For one operator watching one loop, it's more than enough.
The takeaway for a small team
The broader signal across this week's model launches is that vendors are now competing on agent-workflow efficiency, not just raw capability — fewer calls, tighter code, confirmation before costly steps. That's genuinely good direction. But every one of those claims is a number someone else measured on tasks you'll never see.
If you're a solo builder or a small team, the move isn't to pick the model with the best-sounding efficiency blurb. It's to build the thin layer that logs your own calls, gates your own spending, and lets you swap models underneath without changing how you measure. Once you can query your own cost, the launch posts become what they always were: a starting hypothesis, not a receipt. You can host the whole thing on the platform and keep iterating, which is what turned this from a weekend experiment into something I actually kept running.