Lattice
Astra doesn't run out of context mid-task
Start new thread

Lattice - Astra doesn't run out of context mid-task

by•
Lattice sits on top of Codex and controls what the model sees at each step. Same model, same behavior - 76% less text sent per task, 62% faster, 4/4 tasks accepted. Long refactors finish instead of dying at 60% of the window.

Add a comment

Replies

Best
Maker
📌

Hey! I'm the only person behind Lattice.

It started with a dumb observation: my long refactors in Codex kept dying around 60% of the context window, and the numbers on screen didn't match what I was actually sending. I went into codex-rs and found that after a rollback the token count gets recomputed with a local heuristic (estimate_token_count) instead of the usage the server already returned. The thing telling me how much room I had left was guessing.

Lattice is what came out of that. It runs on top of Codex and controls the disclosure boundary - what the model actually sees at each step. Not a prompt optimizer, not a summarizer, no model swapping. Same model, same behavior, less text.

My own runs on GPT-6 Astra: 76.26% less fresh input+output per task, 61.59% faster, 4 of 4 tasks accepted. One independent run on someone else's machine and a different model reproduced the mechanism; that log is in docs/evidence, numbers and all.

The honest state of things: Codex is the path I'd put in front of you. The Claude Code integration is still beta because I've had nobody to break it. 12 stars, no real users yet. I'd rather write that than pretend otherwise.

You can check the whole thing locally without an account and without spending a token - npx /lattice doctor --workspace . runs on your own repo.

If you push long engineering tasks through Codex - where does it break for you: the window itself, or the numbers lying to you about the window?

OpenAI
GPT-6 Astra Challenge
What became possible in your product with Astra that was not practical before?
Maker
Before Astra, the limiting factor in a long engineering task was the model losing the thread, so the useful tools were prompt tricks and summarizers. Astra holds a multi-step task to the end. That changed what was worth building: the remaining constraint is mechanical, not cognitive. It is what the model is allowed to see at each step, and whether the reported numbers about that are accurate. I built Lattice for that constraint. It runs on top of Codex, which runs on Astra. It bounds the repository context sent at each step, runs edits in an isolated Git worktree, verifies patches by fingerprint, and checks the model and reasoning effort the provider actually served against what was requested. It does not summarize and does not swap models. My runs on GPT-6 Astra: 76.26% less fresh input and output per task, 61.59% faster, 4 of 4 tasks accepted. Long refactors complete instead of stopping partway through the context window.