SANNR.
alpha invites open
est. 2026

sannr.dev / api / transmission 002

Your API
has a
backstory.

The prerequisite nobody wrote down. The call that returns 200 and quietly does nothing. The reason you chose that approach over the other one. Sannr gives coding agents a place to keep those lessons beside the code, so the next agent starts with what your team already learned.

Tribal knowledge,
at agent speed.

private alpha in progress
keep your tools. bring what you've built.
or follow the signal

private alpha

Get in the alpha.

We'll use this to send your invite and Sannr launch updates.

Sannr (pronounced SAH-ner, Old Norse for “true”) is a developer tool for teams whose code is written with coding agents such as Claude Code and Codex. It keeps what those agents learn about your APIs, the prerequisites, the quirks, the decisions, in a committed .sannr folder next to the code, verified against the live service and delivered to the next session on every clone. It runs as a CLI and as an MCP server on macOS and Linux. Sannr is in private alpha; it is not the .NET validation library of the same name.

what's coming

Keep your tools.
Bring what you've learned.

A team already has collections, specs and a few hard-won lessons. Sannr is additive: it sits beside what you have and keeps what the next developer or agent needs to know.

Bring what you have

Import the collections and specs you already use: Postman, Bruno, Insomnia, OpenAPI. Every import reports what it couldn't carry over instead of pretending it did.

Lessons live with the code

What an agent learns about an API is saved as a lesson in a committed .sannr folder, with where it came from. Clone the repo, bring the knowledge.

Built for coding agents

Sannr runs where your agent works, Claude Code and Codex to start, and makes each saved lesson available to the next session. No accounts, no telemetry.

what it is

Three things,
one folder.

Sannr is three things that share one committed folder.

A map.

Point it at a repository and it inventories the APIs it finds: the services, the routes it recognizes, who calls whom, and where a contract and the running server disagree. The map is generated from your files, offline, without calling anything.

A knowledge file.

.sannr/stacks/sannr.json records what agents observe about each operation: response shapes, the enum values a contract declares, the gotchas the documentation omits, and the decisions no traffic ever reveals, such as why an integration was rejected. It is committed with the code, so whoever clones the repository inherits it.

A client.

A request client your agent calls through MCP or the command line. It sends the request, applies your credentials from environment references, returns a bounded result with the assertions you asked for, and records what it observed. The client is the sensor; the folder is the product.

how it works

Import. Verify. Deliver.
Keep it true.

How it works, in detail

Import what you already have.

Sannr reads Postman, Insomnia and Bruno collections and Kong configuration, and seeds operations from an OpenAPI contract. Every import comes with a loss report that names what it could not carry over. A test script it cannot translate faithfully is quarantined and reported, never silently dropped or silently faked.

Verify against the running service.

Read-only checks record what is actually true about each operation: the status codes seen, the field names and types, the drift between the contract and the server. Field values are never recorded unless the contract itself declares them; request and response bodies, headers and credentials never are.

Deliver it where the agent already reads.

The verified facts and the authored lessons are projected into the instruction files your agent loads at the start of a session, so it starts from what the team knows without being told to go and look.

Keep it true.

A CI workflow runs Sannr's audit on every push and on a weekly schedule and reports, in the job summary, where your code, your contract and the saved knowledge disagree. It makes no API requests, and it never rewrites your contract or your notes.

who it's for

Teams that
ship with agents.

Sannr is for developers and teams who use coding agents to build and integrate APIs: your own services, and everyone else's. If an agent on your team has ever re-discovered the same undocumented precondition a colleague hit last month, that is the problem. Sannr is additive. Keep your API client, your collections and your specs. It sits beside them and keeps what the next developer or agent needs to know.

It works today with Claude Code and Codex. Node 22 or newer, macOS or Linux.

what stays put

No accounts. No telemetry.
Nothing phones home.

Sannr has no account to create and sends nothing to us. Credentials are referenced by environment variable name; the configuration stores the name, never the value. Recorded knowledge holds field names and types, and only the values a contract declares. Request evidence stays in a local folder that Sannr's own .gitignore keeps out of the repository. The knowledge file is the only thing meant to be shared, and it is designed to be safe to commit.

terms

The words
we use.

API context Everything an agent needs to use an API correctly that the specification does not say: prerequisites, quirks, rate limits, the reason a decision was made, and how recently each fact was checked.
Tribal knowledge The working knowledge of a system that lives in the heads of the people who have been around longest and is not written anywhere a newcomer, or an agent, would find it.
The rediscovery tax The cost of an agent re-deriving, in a fresh session, something a previous session already learned about the same API.
Authored lesson A short note recorded on an operation by a developer or an agent, with its evidence, describing behavior the contract does not say. Sannr delivers lessons to later sessions.
Loss report The part of an import that names what could not be carried over faithfully, so a green import never means more than it should.
Drift A difference between what the contract or the saved knowledge says and what the running service does now.
Repository-level context Knowledge committed with the code, so every clone, every host and every person who touches the repository inherits it. Your agent's host may keep memory for you on your machine; the repository is what everyone else pulls.

honest signal

What we can say,
and what we can't.

We named it “true” for a reason. Every claim on this site should be checkable, so here is where the line is today.

We can say that Sannr records what agents observe about an API beside the code, verified against the live service, and delivers it to later sessions; that imports report their losses; and that nothing is sent to us.

We cannot yet say how much time or money it saves you, that it beats a well-kept markdown file, how it behaves on large estates, or what it does for a whole team over months. We have not measured those. When we publish a number, it will come with the experiment behind it.

tune in

Catch the
next drop.

known signal

What is Sannr?
A developer tool that keeps what coding agents learn about your APIs beside the code, verified against the live service, and delivers it to the next session. Private alpha now; no public package or pricing yet.
Is this the .NET validation library called Sannr?
No. That is an unrelated open-source project. This Sannr is sannr.dev, a tool for teams using coding agents to build and integrate APIs.
Do I have to drop my API client?
No. Keep the collections and tools you already use. Sannr imports them and sits beside them.
Which agents does it work with?
Claude Code and Codex, through an MCP server and a command line. Node 22 or newer, macOS or Linux.
What does it import?
Postman, Insomnia and Bruno collections, Kong configuration and OpenAPI contracts, each with a loss report of what it could not carry over.
Does it send anything to you?
No. There is no account and no telemetry. Credentials are referenced by environment variable name and never stored. The invite form on this page is the only thing here that talks to us.
What gets committed to my repository?
A .sannr folder with the knowledge file, configuration that names environments and credential variables, and the skills your agent uses. Local request evidence is ignored by Git.
How is this different from writing a markdown file?
A well-kept markdown file works. Sannr is the thing that produces and maintains that file from verified observation, and checks it against the service so it does not quietly go stale. We have not yet measured Sannr against a hand-kept file, and we say so.
How do you pronounce it?
SAH-ner. Old Norse sannr, meaning “true.”
When is it launching?
Not announced. Alpha invites go out first. The date will hit the accounts on this page before anywhere else.

who

Built by a developer
who kept walking over to Joe.

Sannr is built by Sterling Chin in the San Francisco Bay Area. Before this he spent four years at Postman, including leading R&D for its AI assistant, and a decade as a developer and engineering manager before that. He writes about APIs, coding agents and the knowledge that never makes it into the docs on LinkedIn and X.