Why Behavioral Intelligence Exists

It started with a terrifying commit. One night I asked an AI assistant to refactor a service I'd been carrying for months. The kind of code where you know which functions to trust and which ones you've patched around so many times they've become structural. I gave it a clear instruction. Minutes later, Git showed me something I'd never seen: 453 files changed.

The code compiled. That was the worst part. There was no error to chase, no failing test to tell me where the damage was. Just a diff too large to read fast enough, touching files I hadn't intended to be in scope, in ways I couldn't verify before they'd be merged into something downstream. I scrolled through it knowing that some of those edits were going to surface as bugs in three weeks, or three months, in code I'd forgotten was related to code I'd asked the AI to change. I couldn't tell which ones. The blast radius was unknowable.

That night I realized the problem wasn't that the AI had broken things. The problem was that no tool I owned could tell me what it had broken, which parts mattered, or which fragile corners of my codebase had just been silently rewritten by something that didn't know they were fragile.

The industry's response to AI-generated code has been to build more of what already existed. More static analyzers. More code-indexers. More retrieval systems that hand AI agents more context so they can generate more code more confidently. None of it watches what the agents actually do. None of it learns, over time, which parts of your codebase break when AI touches them. None of it remembers what the last agent tried so the next one doesn't repeat it.

This is a structural blind spot, not an incidental one. Code intelligence tools index what exists. AI coding tools generate what's next. Nothing in between observes the relationship - what got changed, by whom, with what consequence, and whether the same pattern is about to happen again. That gap is where the 453-file mistakes live. That gap is what Vreko fills.

We call it behavioral intelligence: watching what your agents do, learning which files break under pressure, and giving the next agent memory of what the last one tried. From the first vr init, Vreko begins in a BOOTSTRAP state - honest about the fact that it doesn't know anything about your codebase yet. We chose to make that visible rather than hide it behind a confidence bar that's lying about what's possible.

As you work, as your agents work, Vreko enters CALIBRATING: building a model of which files move together, which patterns precede regressions, which corners of the codebase your AI tools consistently misunderstand. Eventually it reaches STEADY_STATE, where it has enough behavioral signal to be useful - surfacing fragility before the next session touches it, attributing changes to the agents that made them, catching the patterns that have caused you pain before.

This isn't a scan. It's a relationship that compounds. The more you build, the more your codebase teaches Vreko, and the more honest the intelligence becomes.

Vreko runs on your machine. Not metaphorically - actually. The daemon is a local process. Your code does not leave the disk it already lives on. What syncs to our servers is behavioral metadata: file paths, change sizes, timestamps, the agent that was active during a change. The diffs themselves stay local. The file contents stay local. The intelligence we build comes from observing patterns, not from reading your code.

I won't install software on my own machine that ships my code somewhere I can't see. I'm not going to ask you to either. The full list of what does and doesn't sync is published at vreko.dev/security. If a field isn't on that list, it doesn't leave your machine.

Vreko isn't useful yet. Not the way it will be in six months. Behavioral intelligence requires real codebases under real pressure to learn anything worth knowing. A model trained on toy repos and clean codebases is a model that fails the moment it meets production. The Pioneer cohort exists because we need codebases with real complexity, real fragility, real AI agent activity - the kind of codebases where the 453-file mistake is one of several you've had to live through.

If you've watched an AI agent damage code you cared about; if you've felt the specific exhaustion of explaining your codebase to a new agent for the fourth time this week; if you believe that the tools we use every day should learn from how we use them - then you're who we built this for. Pioneers help us learn what Vreko needs to become. In exchange, you get locked-in pricing on whatever you eventually choose, direct access to the team, and first sight of features as they ship.

I owe Pioneers honesty about what works and what doesn't, and the discipline to ship the fixes faster than excuses. I owe the developer community a workspace.json open standard that doesn't lock anyone into Vreko - including the parts of Vreko I haven't built yet. I owe my own future self a tool that catches what I missed that spring night.

Vreko started as a reaction to a 453-file mistake. The commitment is to make sure no one has to live through theirs alone.