At Impossible Computing, we’re building an agent enhancement service we call Overtrack. It works alongside the AI agents and tools customers already use, turning execution history into useful memory, evaluations, and reusable skills, and managing the context an agent needs as a task unfolds. The product question is whether we can improve completed work while reducing the time and cost it takes.
Gearshift is the name of the research project in this post, exploring one possible capability for that service: let a larger model do the difficult reasoning, then let a smaller, cheaper model finish the job without losing what the larger model had worked out. The practical test was whether the complete system could beat a simpler way of doing the same job.
In my first Gearshift post, I described an attempt to let a large model do the hard reasoning and hand the rest to a smaller model. Instead of asking the smaller model to reread the larger model’s work, I tried translating its attention state directly.
The translator was improving. The complete system still lost to simpler alternatives. And the reread I was trying to eliminate accounted for only about 0.2% of the recorded time on that coding workload.
I ended that post saying I would go after the expensive part.
The follow-up work explored earlier handoffs, a learned policy for choosing when to hand off, and more direct tests of what a cache translator could preserve. One narrow result held up: useful factual context can cross between these models when the information is arranged in a particular way. The more interesting result I wanted, reliable transfer of useful reasoning with better system economics, did not emerge.
I’m stopping this version of Gearshift. The results don’t justify making Overtrack depend on it. We can use what we learned about context and model handoffs in a simpler system while leaving the harder research questions open.
The comparison that kept mattering
A transformer’s KV cache is the attention state it keeps for tokens it has already processed. Gearshift learns a conversion between one model’s cache and another model’s representation. The language models stay frozen; the trainable part is the cache mapper. That lets the second model continue without processing the original history as text.
The important baseline is still ordinary text. Give the receiver the same information and let it read it normally.
This sounds obvious, but it changes how to interpret an otherwise encouraging result. A translated cache can beat an empty context or an unrelated cache while still being much worse than reading the actual source.
The first post already showed this on coding. Across 200 tasks with three answer draws each, native text handoff passed 390 of 600 draws. The smaller model working independently passed 330. The stronger of the two primary cache-handoff variants passed 229. Broader training coverage helped the translator, but it did not make the handoff economically competitive.
A result worth keeping
Some of the clearest later tests used fictional service graphs: small invented worlds with facts and relationships the models had to retrieve or follow. They let me control the information being transferred without relying on what a model might already know. One flaw, though, is that this prevented me from taking advantage of knowledge and relationships the larger model had (that the smaller model did not) and “lowering” it into the transformed cache. This is a worthwhile avenue of future research.
Grouping related facts turned out to matter a great deal. On a fresh evaluation with 128 questions and three seeds, translated state from a 32-billion-parameter model to a 14-billion-parameter model produced 377 correct answers out of 384. Reading the same context normally produced 384. Both negative controls scored zero.
That is a useful (positive!) result. The translated cache carried enough of the source information for the receiver to answer almost as reliably as it could from text.
A later test reused the mapper on fresh graphs. With grouped facts, translated state scored 63 of 64 against native text’s 64. With facts interleaved, it scored 21 of 64 against native text’s 27.
Even the native receiver had trouble with the interleaved layout. The representation of the input was doing substantial work before cache translation entered the picture. I’d also like to test a more capable receiver: for example, handing off from a 500B model to a 100B model. The smaller model in that pair might handle interleaved facts better, letting us test whether receiver capability is part of the bottleneck.
These are synthetic tasks with specific layouts and a particular model pair. They show that cross-model context transfer can work in a bounded setting. Copying facts successfully was a necessary step toward the idea I wanted to test, but there was still another experiment to do.
When the donor had something useful to say
I moved toward tests where the larger model wrote a note and the receiver used it to answer. The crucial comparison gave the receiver the same source and the same note, either as ordinary text or through translated cache state.
There were reasons to keep going. In one development experiment, a newly trained, task-matched mapper reached 37 correct answers out of 64. Text reached 39. The previous mapper had managed only 12. I liked seeing that improvement, though it still did not resolve how much note-specific benefit survived the translation.
The next experiment, E72, froze that mapper and tested 32 new fictional graphs using new identifiers and two different presentation templates. The donor’s note was generated before the final question. None of the notes disclosed the final answer. The receiver got the identical visible history through the two routes, alongside wrong-note, unrelated-history, and no-note controls.
-
Source and donor note as text: 16 of 32 correct.
-
The same history as translated KV state: 3 of 32.
-
Source as native text without the note: 9 of 32.
The note helped when the receiver could read it. Translation lost 13 cases that text got right and recovered none of text’s misses. All answer conditions completed, with no missing, invalid, or capped outputs and no exclusions.
The translated wrong-note and unrelated-history controls both scored zero. So there may still be context signal in those three correct cache answers. But the useful comparison was three against sixteen.
This was a development test on 32 invented graphs, using a mapper fixed before the test. I haven’t run the separate 128-graph confirmation set. The result tells me how this version performed on these tasks, not how every possible handoff will perform.
That’s enough for a product decision. Overtrack’s customers need agents that finish useful work reliably, at a cost and speed they can live with. Cache translation would add model-specific infrastructure, failure modes, and maintenance while giving them worse answers than the same information delivered as text. I’d rather spend that engineering effort on the simpler system. A research idea can remain interesting without becoming a dependency for the product.
Earlier handoff did not establish a systems win
The economic problem from the first post remained. If the large model has already spent most of the time reasoning, skipping the receiver’s quick reread cannot save much.
I tried handing off earlier. On 50 fresh coding tasks, handing the receiver a fixed 4,096-token prefix of the source’s reasoning matched the receiver working independently: 40 correct answers out of 50. Including the source work, the handoff required 66.1% more reconstructed stage time.
A learned boundary policy did not find a better choice. On its 50 outer held-out tasks, it chose the same 1,024-token boundary, or an earlier natural end, as the simple controls. It did not establish an advantage for choosing the boundary adaptively.
Text assistance did help in some other small tests. A later part of the reasoning trace sometimes helped more than an early prefix. But the benefit depended on the task, the receiver, and how the information was presented. And, in one software code-generation screen, assistance made the result worse.
None of this produced a demonstrated end-to-end serving-speed or all-in cost advantage. The earlier 0.2% calculation was a hypothetical ceiling for removing receiver prefill on one recorded workload. It remains a good explanation of why that particular optimization was a poor target.
The expensive stage was the source model’s reasoning. Any useful follow-up has to account for that cost, not just the time spent on the handoff.
What I am taking from this
The narrow positive findings still count. Broader supervision improved a mapper. Grouped factual context transferred well in a controlled setting and again on fresh graphs. Ordinary context organization sometimes made a large difference without any translator at all.
The negative results count too. The more demanding handoffs repeatedly lost to the same information delivered as text. Early handoff did not establish a useful quality-and-time tradeoff. The learned router did not earn its added complexity.
For Overtrack, that brings me back to the product goal I started with: help existing agents do better work at a sensible total cost. I’d start with a single adequate model and well-organized context. Where a larger model’s help earns its extra cost, ordinary text handoff is the baseline to beat. Gearshift hasn’t earned the additional machinery of model-specific cache conversion.
That is a narrower conclusion than saying models can never share useful internal state. One of the results here shows that they can, under specific conditions. I just did not turn that capability into the system I set out to build.
What comes next
We’ll use these results to build a simpler system in Overtrack, carrying forward what we learned about organizing context and handing useful information between models. We’ll also pursue more research, including the knowledge-transfer and larger-receiver questions above. Overtrack can move forward without waiting for those answers.