Tangent

Inspiration

Each AI copilot for coding currently available on the market addresses the same problem by doing the exact same thing in the exact same costly way, which is using the state-of-the-art model for each and every step of the build process, starting from a simple file read operation through the whole architectural design process. That works well for a person who wants to make a small change. But it does not make any sense once you start building a serious application, because that is not 5 requests, but thousands of them. Everyone is pursuing more capabilities. No one is pursuing more capabilities per token.

What it does

Tangent is a coding IDE with a swarm of specialized agents working underneath it, but the part we actually care about is how those agents talk to each other. Instead of every inter-agent message being a full, human readable chunk of natural language, agents in Tangent communicate through a compressed, pseudo-neuralese protocol for this POC, a denser representation that carries the same planning and state information at a fraction of the token footprint. You type a goal into the IDE, the swarm breaks it down and builds it, coordinating the way it always would. The difference is invisible to you and very visible on the token counter.

How we built it

We built the whole agent backbone on top of Codex, and honestly can't overstate how much that model pulled its weight here. We handed it a rough shape of what we wanted, an orchestrator, a set of specialized builder agents, a message bus between them, and Codex turned that into working scaffolding fast enough that we spent our time on the actual hard problem instead of boilerplate. From there we stripped it down, rewired the communication layer to carry compressed messages instead of plain text, and wrapped the whole thing inside an actual IDE, file tree, editor, live agent activity feed, so you can watch the swarm work instead of trusting it blindly.

Challenges we ran into

Getting a multi-agent swarm and an IDE to actually live in the same product was harder than either piece alone. The swarm wants to be an async, event-driven backend. The IDE wants a UI that feels responsive on every keystroke. Gluing those together without one blocking the other took real work. The pseudo-neuralese layer was its own fight: compressing agent messages saves tokens, but only if the receiving agent can still reliably reconstruct intent from the compressed form. Push it too far and agents start misreading each other, which costs more in retries than the compression ever saved.

Accomplishments that we're proud of

We shipped an actual IDE, not a demo of a concept, one you can open, type a goal into, and watch a swarm build inside. The compression work paid off too: early runs show roughly 10 to 15% lower token spend on inter-agent chatter compared to the same swarm talking in plain text, with no drop in build quality. Getting a compressed agent protocol to hold up under a real build, not just a toy example, is the thing we're most proud of walking away with.

What we learned

Compression is a tradeoff you have to actively manage, not a free win. There's a real line between "save tokens" and "lose enough fidelity that agents start working around each other instead of with each other," and finding it took more tuning than we expected going in. We also learned that IDE level UX and agent level orchestration pull in different directions. Building for both at once forces tradeoffs neither side would make on its own, and that friction taught us more about the product than either piece would have alone.

What's next for Tangent

The next big step is hosting the LLMs ourselves instead of calling out to hosted APIs. That's not just about cost, it's what unlocks the real prize: access to KV caches. Right now every agent starts its reasoning cold. With native hosting we can persist and hand off KV cache state between agents, so one agent's computed context seeds the next agent's start instead of everyone recomputing from scratch. That's a much bigger lever on cost than message compression alone, and it's the next thing we're building.