Better Together, Now in Code

We have been saying it for a while: brilliant alone, unfair together. Until now the “together” part was a promise about how the pieces fit in principle. As of this release it is code that runs. The cross-product wiring shipped, and it is real, not aspirational.

Here is the part that matters most, said up front so nobody has to hunt for it: none of this makes any product depend on another. Every connection below is presence-gated. If the sibling tool is not connected, the integration is simply a no-op, and the product you installed keeps doing exactly what it did on day one. You never buy the stack to get the tool.

Memory that arrives before you ask for it

Agents forget. That is the flaw Curator exists to fix. What is new is that Curator no longer waits to be queried. When it is present, it can push the relevant history and decisions into the agent’s turn unasked, so the agent starts from what already happened instead of from a blank slate. The context that used to sit in a memory store, one careful lookup away, now shows up where the work is.

If Curator is not connected, nothing changes for you. The agent runs as it always did. The push only happens when the memory is there to push.

Verified facts instead of another file read

TheAuditor has always given an agent a deterministic picture of your codebase. Now, when it is present, it can hand the agent verified facts as structured data, directly. The agent stops re-reading raw files to reconstruct what is already known and true. It gets the answer as a fact, not as a pile of text to parse and half-remember.

That is a smaller context window spent on the actual task, and fewer chances to misread a file into a confident wrong conclusion. And if TheAuditor is not in the room, the agent falls back to reading like always. No hard edge, no broken flow.

Supervision that stays deliberate

Arbiter supervises long-running work. The new behavior: when Curator is connected and supervision is enabled, Arbiter can account for its long-running work alongside the rest of the operation. The connection removes duplicated setup without removing operator control.

This is the shape we want for all of it. You should not have to assemble a stack by hand to get the benefit of a stack. When the pieces are connected, they cooperate. When they are not, each one still stands completely alone.

Why optional connections are the whole design

It would have been easy to make these connections mandatory and call it “deep integration.” We chose the harder line on purpose. A connection that becomes a hard dependency turns a product into a hostage of the others, and a product that is only good inside a bundle is not really a product. So every integration here remains optional and does nothing if its sibling is absent.

The result is that adopting one tool never quietly commits you to five. You get the standalone win you came for, and the compounding is there waiting when you want the next layer, never charged to you up front.

Fresh proof of the thesis

This release is the clearest evidence yet that “brilliant alone, unfair together” was not a tagline we hoped to grow into. It is how the software actually behaves now. Each tool earns its place by itself. Connect two, and one quietly makes the other better. Connect all five, and the failure modes you used to just live with start disappearing.

Start wherever it hurts most today. Every front door in Code Reality Labs opens on its own, and now they open onto each other too.