The Archstone console is free on every plan until 1 December. See the plans →
A business-level description in; MCP tools and SDKs out, with a verifier that tells you, field by field, when your API drifts from it. Everything on this page is the actual mechanism — the plain-language version is on the homepage.
tourism_search is a real, working example — already built, hosted live.
This works the same way on Mac, Windows, the web, or your phone: no config file, no
terminal, no sandbox account.
https://demo.archstone.dev/mcp
Then ask about a trip — a destination, a date range, a budget. Claude looks it up against a real backend and answers from what it finds: the exact scenario below, live.
claude mcp add --transport http archstone-tourism https://demo.archstone.dev/mcp
For transparency: this demo's backend returns fixed, deterministic data — not a live operator's real inventory — so you can see the exact shape of what comes back. Same query, same result, every time. Curl it yourself:
curl -s -X POST https://demo.archstone.dev/v1/search \
-H "content-type: application/json" \
-d '{"destination":"Rome"}'
{
"stays": [
{ "id": "stay-5-0", "name": "Riverside Lodge — Rome", "location": "Rome",
"pricePerNight": 225, "rating": 4.1 },
{ "id": "stay-2-1", "name": "The Olive Court — Rome", "location": "Rome",
"pricePerNight": 278, "rating": 4.5 },
{ "id": "stay-9-2", "name": "Harbor House — Rome", "location": "Rome",
"pricePerNight": 331, "rating": 4.9 }
]
}
Prefer everything on your own machine —
model included? archstone serve speaks the same protocol over stdio, so a
local model via Ollama or LM Studio calls it exactly like Claude does above — no cloud,
no code changes. Copy-paste config in the
open-source docs.
Want to see everything it does, not only a search? The technical demo → runs each capability in your browser on sample data: compile a declaration into a tool, see what a model never receives, catch a drifting API, refuse a call and read the audit record. Each one comes with the command to run it yourself.
That's our API, live. Want the same look at yours? Verify my API → — paste your own OpenAPI document and see what an agent gateway would call, free, read-only, nothing stored.
You describe a capability — what your business can do, in plain business terms, not code. Archstone compiles that into the tools each AI calls, and tells you when your API stops matching it. Three steps, and the last one repeats for free.
State the capability — its inputs, its result, who may call it. Already have an
OpenAPI document? archstone init drafts it for you and asks only what no
spec can answer, like whether a call can change something.
The compiler validates it, maps it to your real endpoint, and emits the tools — with policy, rate limits and an audit record on every call. Nobody hand-writes integration code.
The same capability is discoverable and callable across models — new assistants added without touching your systems.
# a capability is what you do, not how your API is wired capability: id: tourism.search description: Find places to stay matching a traveler's destination, dates, party and budget. effect: read input: destination: { type: location } dates: { type: date-range } # prices vary by day travelers: { type: party } budget: { type: money, required: false } output: stays: { collection: Stay } # from your portfolio only provider: booking-engine
Already comfortable building an MCP server yourself? Then the work was never the first server — it's the fifth one, after ChatGPT's, Gemini's and whatever comes next each want it shaped slightly differently, and your API changes underneath all of them. Archstone generates every one of those from a single description and tells you, field by field, when your API drifts from it — so that maintenance shrinks to one place instead of multiplying. Why a compiler, not the fifth MCP server →
Some teams would rather not manage their own server — that's fine. Hosting is optional, and it's pure utility: no bidding wars that rank one business above another. We host the technical bridge; you keep absolute control over where it leads.
Self-serve, in the console: sign up, point it at your OpenAPI description, choose what an agent may call, make one real test call, and publish an MCP endpoint — no card, nothing to install. Start free →
Endpoints are key-protected for Claude Code and Cursor, or public for connectors like claude.ai, or protected by sign-in for browser connectors. Capabilities that can't be undone are still on the way.
Internal use is the same manifest behind a
key-protected endpoint. Declare effect: write or irreversible and
every MCP client is told so on the tool, so clients that surface it — Claude Desktop,
claude.ai — can put a confirmation in front of a person before calling it. Typed tool
definitions carry no equivalent. Archstone discloses the effect; it does not enforce it.
policies: [human-approval] is accepted today and not enforced —
archstone apply warns you by name — and a server-side approval gate is not
yet built. For an irreversible capability, archstone apply and
archstone doctor also warn when it declares no failures, does not
declare policies: [authenticated] (and has no Policy allow list),
or names a policy this version does not enforce. These are checks on the declaration, not
on your backend — archstone verify is the check against the provider — and
they never change an exit code.
Onboarding
docs →
Everything that turns your description into something an agent can call is Apache-2.0
and stays that way — the language, the compiler, the IR, every emitter, the SDK, and
the whole CLI: init, apply, build,
serve, verify. archstone build and archstone serve never
need a network call, an account or a key. Vendor a manifest, pin a version, and you
can keep compiling and serving it forever with no relationship to us. ArtVinci runs
entirely inside that, and owes us nothing.
Nothing that is free today will become paid. What we charge for is the part that only exists over time, on our machines — written down, in the open, before we sold anything: what is free, and what we sell →
A contract with an agent breaks silently: the field is gone, the tool still answers,
the customer gets nonsense. archstone verify replays a real recorded call
against your live backend — free, on your machine, one shot. The console runs it on a
schedule, keeps the history, and calls your webhook when a binding goes red.
Every execution already emits a structured record — the hooks and the local sink are open source. The console collects that stream, keeps it for the retention you set, and makes it searchable and exportable across capabilities and time, so spend and refusals are answerable questions rather than a log file somebody greps.
For teams who would rather not operate a node. Pure utility — no bidding, no placement, no business ranked above another. Same compiled IR you built yourself, running somewhere you don't have to be on call for. More on hosting ↑
All three are live in the console today, and the Free plan includes them: drift history, audit and hosting. Starter, Growth and Enterprise raise the limits — retention, calls, hosted deployments — and add support. Sign up and do it yourself → Compare the plans →
If you would rather not, we take five design partners through it by hand: we write
the first capability against your real API, wire
build and verify into your CI, and ship it to production with
you — the same path ArtVinci took, minus the part where we were debugging the compiler
along the way. Paid, fixed scope, your manifest lives in your repository and keeps
working whatever happens to us.
That opens an email with the four things we need to know — what your business does, what you want an agent to be able to do, what API is behind it, and where it should run. Answer them roughly; we'll reply with whether it's a fit and what it would take.
Start free in the console, or vendor the open-source core and never talk to us again — both are fine.
or write to us directly at hello@archstone.dev