Strata19 for Antigravity

A project intelligence layer for AI coding harnesses. Strata19 maps your codebase, connects it to the specs that define done, and turns the gaps into work an agent can pick up on its own.

Comment

Inspiration

Coding agents understand the conversation they're in. They don't understand the project they're changing.

That's the whole gap. An agent opens a few files, infers the rest, and answers with exactly the same confidence either way — whether it checked or guessed. Which is fine while you're reading every step. It falls apart the second you want to walk away and let it work.

I kept coming back to finished tasks with no way to separate what had been verified from what had been assumed. The code usually looked great. That was the problem. Nothing in the loop knew what the project was supposed to be, what had already been looked at, or what "done" was supposed to mean here — so "done" quietly became "it compiles and the agent stopped talking."

I wanted a layer underneath the agent that actually knows the codebase, knows what done means, and can tell you which of its answers it earned.

What it does

Strata19 gives the agent the project.

It indexes your repository into a live map — symbols, imports, call graph, blast radius — and connects that map to the specs that say what's supposed to be built. Where the two disagree, the gap becomes a finding or a piece of work with a real file and a real line attached, because something deterministic actually went and looked. No model opinions anywhere in the facts.

On top of that: work items, change sets, checkpoints, and routines — declarative multi-step workflows an agent can run. Fifteen ship with the plugin, across twenty-four registered action kinds, at three autonomy levels: review, suggest, automate.

And there's a workspace over all of it. Every routine with its step count and autonomy level, plus items, runs, activity, deliveries, and a findings view that will tell you eighteen detectors ran and twenty-one didn't — instead of showing you a comforting zero.

The part I built for this hackathon is what happens when nobody asks it to do anything.

A turn ends. Nobody types anything. Strata19's Stop hook fires, reads the files that were just touched, computes what's actually wrong inside that scope, and then asks Gemini the one question no detector can answer: given what this developer was just working on, is any of this worth interrupting them over?

If the answer is no, nothing happens and it stays quiet. That matters more than it sounds — an assistant that interrupts you every time it could is one you turn off in a week.

If the answer is yes, a routine starts that I never requested. It narrows a hundred-plus findings down to the few that matter right here, groups the ones that share a root cause, and assembles a single change set: what it wants to do, and its written reason for thinking it's worth doing.

Then it stops. Nothing in the working tree has been touched. It found the work, planned it, and waited for a human.

That's the whole pitch in one line: an agent that starts on its own, and then deliberately doesn't finish.

How we built it

The plugin is an MCP server that Antigravity connects to over stdio, backed by a local SQLite store and a tree-sitter symbol graph. The detectors that produce findings are ordinary code — no model involved at any point — so every finding carries a file and a line you can open and check. That boundary is the entire design, not a detail of it.

Gemini 3.5 Flash Lite has exactly one job: judgment. Which of these true things matters right now, and is acting on it unprompted a good idea. It runs through the Google GenAI SDK. If the model isn't reachable, no routine starts — it will not guess a trigger and then dress the guess up as a decision.

It ships from a release hub on Cloud Run, with images and release archives in Artifact Registry. Publishing happens in two phases: deploy at zero public traffic, verify the revision directly, then promote. Part of that check compares the bytes actually being served against the archived manifest digest, rather than assuming they match because the upload said so.

One thing I'd rather say plainly than let you infer: Strata19 didn't start at this hackathon. What I built during it is the autonomy layer — the Stop hook, the routine engine and the fifteen routines that run on it, the Gemini judgment call, the Antigravity host integration, the workspace surfaces, and the Cloud Run release path. That's 409 commits across 435 files in this window. The project intelligence underneath is older, and I'd rather tell you that than imply I wrote a code graph in a weekend.

Challenges we ran into

Every install proof I had was against a fake server. All my install, update, and rollback testing ran against a local mock registry that answers instantly. The first install against the real Cloud Run endpoint failed outright — the client had a 5-second timeout, and the real package takes about 2.6 seconds warm. That's a coin flip, not headroom. Three clean installs produced one success and two timeouts.

And my first explanation was wrong. I assumed cold starts, set min-instances=1, and re-ran. It still failed two times out of three. The payload was simply too big for the budget. If I had stopped at the plausible answer, that would have shipped — and a judge following my own install instructions would have hit it.

A credential written to one place and read from another. An API key that kept "disappearing" turned out to be stored under one keychain entry while the code read a different one. Nothing was broken. The two halves had just never been introduced.

Keeping the model out of the facts. The tempting shortcut is to let the model summarize the findings, or grade whether a fix worked. Every single time that boundary slipped, the output got more confident and less trustworthy at the same time.

Accomplishments that we're proud of

The tool argues with me. There's a guard that strips words like "verified" and "proves" out of local-tier output before it reaches anyone. Detectors disclose their own limits — the dead-code check reports, in its own output, that it's an unused-file candidate, not an unused-export claim and not deletion authority. The findings view says how many detectors didn't run rather than implying they all did. It would have been easy to make this thing sound more capable than it is, and a genuinely uncomfortable share of the work went into making sure it can't.

An agent that starts work on its own and then stops. Not because it ran out of capability — because handing a person one reviewable decision is worth more than handing them two hundred findings.

The release path. Digest-checked, two-phase, and independently queried afterward instead of trusting the publish script's own report about itself.

What we learned

A local stand-in can't exercise a network timeout. My mock registry proved the protocol was right and absolutely nothing about real conditions. Both are needed, and only the real endpoint could have found the bug that actually mattered.

The plausible explanation is worth checking twice. Cold starts were a completely reasonable diagnosis. They were also wrong, and stopping there would have shipped a broken install to every judge who tried it.

Splitting the model's job made it more useful, not less. Detectors decide what's true. The model decides what matters. Verification decides whether it worked. Once those three were separated, I could let the thing act on its own — because the part that can be wrong became the part where being wrong is survivable.

What's next for Strata19 for Antigravity

More routines in the same family — root-cause grouping across a whole repository, session catch-up, drift between the specs and the code — and then chaining, so one routine can hand off to the next through durable records instead of through a person.

After that: getting the index to converge on very large repositories, which it currently can't; recording why a proposal was accepted or dismissed so the ranking improves from real decisions instead of my guesses about them; and pushing more of the deterministic surface out to other harnesses, because the project layer shouldn't care which agent is sitting on top of it.

Built With

Share this project:

Updates

Submission history