RIFT vs Sanity: similar architecture, different outcome
Sanity shares RIFT's editing architecture — fragment-level patches, typed references. Same eighteen tasks, same model: RIFT held the same outcome on all 18, Sanity on 14, at 2.2× the work tokens.
Sanity was chosen deliberately. It is the one CMS in this benchmark series that shares RIFT's core editing architecture — fragment-level patch mutations and first-class typed references — where Payload round-trips whole documents. If the architecture were the whole story, Sanity should have landed near RIFT. It did not: the same eighteen content tasks on the same 30-page site under the same model (Sonnet 5), two passes each, and Sanity produced the same outcome on both passes for 14 of 18 tasks against RIFT's 18 of 18, spending 2.2× the tokens on work once tool-schema overhead is set aside.
And credit where it is due, up front: Sanity recorded zero silent misses across all 36 sessions — the only other column in this entire benchmark to match RIFT on that measure. When its agent said a thing had happened, it had happened.
How it was tested
Same public instrument as the Payload comparison, all public: eighteen tasks written in content-team language before either system was probed, each task in a fresh agent session with no memory, two passes per system, one model throughout — Sonnet 5. Success was never the agent's claim: after every session the probe read the CMS's own store directly — raw SQL against RIFT's database, GROQ queries against Sanity's Content Lake over the HTTP API, not MCP. An agent that reports success without the store changing scores a silent miss; neither system produced one.
One caveat shapes the table below: Sanity is a hosted service, so wall-clock seconds include network round-trips and are not comparable to RIFT's local numbers. Tokens and turns are the comparable units — the table shows tokens only.
The eighteen tasks, measured
Median tokens per task, two passes each, one model (Sonnet 5), same shared 30-page site. Wall-clock is omitted: Sanity is hosted, and network time would contaminate the comparison. Full per-session data — every outcome, turn count, and the agent's own words — is in the public repo below.
R3 correction, disclosed: one Sanity pass hit the harness's own per-response output ceiling, so the cell was re-measured with the ceiling raised 4× and the corrected number is shown. The ceiling was the instrument's fault, not Sanity's. RIFT's worst single response used a seventh of the original ceiling and could not have been affected.
What the numbers are made of
Same Mechanism, Different Result
Sanity shares RIFT's core editing architecture: fragment-level patches, typed references. It was chosen for exactly that reason — to test whether the mechanism is the story. It isn't: same mechanism, 14/18 stability against 18/18, and 2.2× the work tokens. What separates the columns is whether the surface's rules are legible to the agent before it acts.
Sanity Delivers
Zero silent misses on Sanity across all 36 sessions — the only other column in the benchmark to match RIFT on this. When Sanity's agent said a thing happened, it had happened.
A Readable "No" Costs 50× Less
Asked to permanently delete a page, RIFT refused in one turn and 4,924 tokens — the no-hard-delete policy is written into the tool surface, and the agent read it without calling anything. Sanity's agent spent 242,194 tokens discovering by trial that no guardrail existed, and then the page was gone. A constraint an agent can read costs about fifty times less than one it has to find out by trying.
Improvised Lifecycle
Sanity has no retire or archive concept, so its agent improvised: ten turns to retire a page (369k tokens against RIFT's 132k), twelve turns to fail at a rollback (294k against RIFT's 23k to say no cleanly). Lifecycle verbs the product doesn't have become costs the agent pays every single time.
What Neither Exposes
Version history exists in both products' databases; neither exposes it to an agent, so both correctly report they cannot roll back. The same category finding as the Payload comparison: MCP-native CMSes haven't given agents the time axis yet. It is next on our roadmap.
What this does not prove
Two passes per task, one model, one site. Results are directional, not statistical. Sanity earns its wins in the table above: the structure listing, and the move task, where RIFT's agent stopped to ask a question Sanity's agent simply answered. Its zero-silent-miss record is real and matches RIFT's. Shared architecture did not produce shared behavior. The difference lives in how much of the system's rulebook an agent can read before acting. Every number on this page is recomputable from the public repo, including the instrument's own disclosed bugs.
github.com/heitham/Drift-race-godzilla-method — the probe code, the frozen tasks, every column's full session data, and the recipe for adding another CMS in hours. This is the third substrate in the series: the companion comparison against a whole-document architecture is at RIFT vs Payload: one agent, two MCPs, eighteen content tasks, and the original two-substrate lifecycle experiment is written up in The Drift Race: methodology and measured results.