Every codebase has a shadow asset: the reasoning around the code. The decision to revert that embedding change. The rule before anyone touches the key boundary. The runbook for the 2 a.m. deploy that wedges. Most of it is durable enough; ours lived right in the repo. But durable isn't the same as useful. It's hundreds of markdown files you can grep but can't ask, invisible to the AI agents doing the actual work, while the context an agent builds up about your project lives in a throwaway local file.
We sell a product built to turn that inert pile into something you can actually query, and that agents can reach natively. So before we opened the doors, we became customer zero: we put our entire software-development knowledge base on Vectros and started running our own engineering org on it. The invite-only window is for exactly that: finding every rough edge ourselves, first.
Durable, but inert
Our docs lived in the repo, so when a disk failure took our working copy down to a backup, the code and the docs re-cloned from the remote in minutes. But a thousand markdown files only get you so far. You can grep them; you can't ask them "why is it shaped this way?" and get the decision back with its rationale. An agent at a cold start can't recall the convention it's supposed to follow from a folder of files. And the one thing that disk failure took for good was exactly the part that wasn't in the repo: the memory our coding agent had built up locally, the conventions and traps it had learned, gone with the machine.
Content vs structure
So we took the whole software-development lifecycle and modeled it as nine typed schemas, split by a single principle: content lives as documents, structure lives as records.
ADRs, designs, references, runbooks, and post-mortems are documents: the prose is the artifact, so you read it and ask it questions. Controls, conventions, gotchas, and the glossary are records: the typed fields are the artifact, so you query and enumerate them. And they link into one cross-surface knowledge graph: a control points to the runbook that proves it, a convention points to the decision that established it, a runbook points to the post-mortem it was born from. Provenance you can navigate, not just search.
What you get back: recall, not storage
The knowledge was already stored. The payoff is that it's finally recallable. "Why did we decide X?" returns the actual decision, cited. "Have we hit this failure before?" surfaces the post-mortem and the gotcha. "What's the active rule for this area?" enumerates the conventions. You query by meaning, by exact lookup, or by following the graph. And an agent reaches all of it natively over MCP, capturing new decisions and recalling old ones in the same loop the team uses. One governed store, human-native and agent-native, instead of a folder only humans can grep and an agent memory only one machine can see.
Finding the rough edges was the point
Being customer zero did exactly what it's supposed to: it surfaced what a demo never will. A firewall rule that ate ordinary markdown on the way in. A search facet that couldn't yet scope by document type. A bootstrap that always landed in the live tenant when you wanted a dry run. You don't hit those clicking through a happy path. You hit them when a real team points a real corpus at the thing and depends on it. Each one got filed, fixed, and shipped, so the next customer inherits the fix instead of the bug. That's the entire reason to be your own customer first.
Stand up your own
The agentic-SDLC knowledge base is a bundled blueprint, so any team can stand up the same governed, hybrid-searchable knowledge base in a few commands:
npm i -g @vectros-ai/cli
vectros login
vectros bootstrap --blueprint agentic-sdlc --no-seed
That provisions the nine schemas, a least-privilege key, and wires up your MCP client. Then
you point an ingest agent at your own docs/, ADRs, and notes. See what it provisions and
how to query it, or read the full walkthrough in the docs.
We built Vectros to be the secure back-end an AI product is built on. The best proof we can offer is the simplest: we use Vectros to build Vectros.