The adoption ladder

You do not have to adopt Vectadyne all at once, and you should not try. There are four rungs. Each one is useful on its own, each takes roughly an afternoon, and each is a strictly larger integration than the one before it.

The order is not arbitrary. Each rung produces the input the next one needs: you cannot get useful verdicts out of an empty corpus, and you cannot judge whether context is worth its tokens until something is measuring the tokens.

Rung 0 — Attach

What you do. Point an existing MCP client at the endpoint with a bearer token.

What you get. Your agent can call all seven verbs. Nothing is stored yet, but the wiring is proven and server/discover is a health check you can put in a monitor.

What it costs. Configuration. Usually no code at all — see Connect an MCP client.

There is no handshake and no session, which is why this rung is as small as it is: a stock MCP client that expects to initialize first will find there is nothing to initialise.

Rung 1 — Memory

What you do. Call memory.remember when your agent learns something, and memory.search at the start of a run.

What you get. Agents stop rediscovering the same facts. This is the rung where the product becomes visible to the people using it, because the second run of an agent is better than the first.

What it costs. Two call sites. In every SDK it is two methods that take a string.

The temptation here is to remember everything. Resist it: a corpus of transcripts is a corpus of noise. Remember conclusions, typed and scoped — see Evidence.

Rung 2 — Analytics

What you do. Replace the hand-rolled “search then build a prompt” step with context.assemble, and report what you actually spent with context.report.

What you get. One call that returns the whole governed context of a proposed action — resolved guides, retrieved memory, a verdict, and citations — instead of you orchestrating three. Plus the first honest answer to what is in my context window and is it earning its place.

What it costs. One call site replaced, and a decision about token accounting.

context.assemble has a server-side latency budget and degrades rather than failing: under pressure it returns a smaller answer with degraded: true, not an error. Treat a degraded assemble as a success — see Degraded mode.

Rung 3 — Governance

What you do. Call preflight.action before high-risk actions, branch on the verdict, write the outcome back with evidence.ingest, and — if you want a hard gate — opt into the CI/PR check.

What you get. Agents that check before they act, an audit trail of what was known at the moment of each decision, and a loop that gets better because outcomes feed the corpus.

What it costs. A branch in your agent loop, and the discipline to close the loop by reporting outcomes.

This is the rung where the advisory-first distinction stops being theoretical. The verdict does not stop your agent; your branch does. That is the design, and the one place it becomes an actual gate is the CI check you explicitly enable.

The governed loop

At rung 3 the whole thing is a cycle:

The dotted line is the point. Without it you have a retrieval system that never learns; with it, the corpus improves every time an agent runs.

Next

• Go · Python · TypeScript — each tutorial walks rungs 0 to 3 in order
• Multi-agent crews — when more than one agent shares a corpus