OpenAPI → reviewed tools → visible state

Let AI act.
Make it prove the result.

MCP is not a side project here. It is a capability inside DoneOS and Inner Quest—generated from each product’s real API, constrained by product judgment, and verified with read-back.

Run the live proofExplore both products
DoneOSexecution that agents can updateInner Questprivate self-knowledge agents can use
The proof loopIllustrated example
You + AIYour request
MCPReviewed tools
DoneOSProduct state
independent read-back
Request01 / 04

Start with what you want.

A person asks. The client chooses a tool from the reviewed MCP contract.

“Create a goal called Launch the first version.”
Run the real proof

The evidence ladder

A handshake is only step one.

Discovery proves a server answered. The useful proof is the chain from a model-visible tool to persisted product state.

  1. 01DiscoverThe endpoint and OAuth metadata answer.
  2. 02List toolsA real MCP client accepts the complete contract.
  3. 03WriteA bounded mutation returns the created record.
  4. 04Read backA separate call finds the exact id and title.
  5. 05See itThe product UI reflects the same persisted state.

A 401 with correct OAuth metadata proves discovery—not authentication, tool execution, persistence, or visible product state.

Live DoneOS sandbox

Create it with MCP. Watch it appear in DoneOS.

23 tools16 writes2h sandbox

This invokes the deployed generated MCP route against a short-lived, private fictional board, then opens the real DoneOS web client in a mobile frame against that exact sandbox. No credential or code path reaches DoneOS production data.

sandboxcreated when you run
Ready. A new token will create a fresh fictional board.

Reset step: press Run again fresh. A new token starts from a clean fictional board and loads a matching DoneOS view.

MCP inside the products

Two products. Two legitimate agent stories.

The adapter is infrastructure. The point is what a person can now ask the product to understand or do.

A task created through MCP appearing in the real DoneOS queueREAL PRODUCT STATE

DoneOS

live proof

Turn a sentence into tracked execution.

Ask an agent to create a goal, add work, start it, or explain a blocker. DoneOS writes the change, reads the board back, and shows the same state in the app.

23public demo tools16bounded writes55generated from spec
Follow the DoneOS story
A reflection created through MCP appearing in the real Inner Quest appREAL PRODUCT STATE

Inner Quest

MCP live

Ask your Personal OS, then save what matters.

Inner Quest combines reflections, relationships, career evidence, values, reading, and personality context. Its MCP can answer from that evidence and write the resulting reflection back into the private product.

143reviewed tools73private writes6write paths repaired

Precise status: the 143-tool MCP surface is on main and deployed. The six free-form writes that previously dropped their request bodies, plus path encoding, shipped on 21 September with regression coverage.

Open Inner Quest

The reusable pattern

Generate mechanics. Review meaning.

OpenAPI removes repetitive adapter work. Product judgment still decides access, language, confirmation, and recovery.

01

Choose

Expose a reviewed product surface, not every route by default.

02

Describe

Tell the model what changes, who sees it, and what success means.

03

Constrain

Keep scopes, schemas, confirmation, and validation in the contract.

04

Prove

Read important writes back through the same authenticated boundary.

INPUTOpenAPI operationschemas · scopes · behavior
GENERATEMCP toolsruntime · manifest · transport
VERIFYProduct statewrite · read-back · UI

Do this on your app

If your app has a spec, this is an afternoon.

The generator is open source and deliberately not an npm package. Clone it, point it at your spec, commit the output. Nothing it writes depends on it afterwards — the HTTP client and dispatch loop are vendored into your app as ordinary source.

github.com/alibad/openapi-mcp ↗
01

Look for a spec before writing one

DoneOS had a 61-operation OpenAPI spec sitting in docs/next to a hand-written 23-tool server. Nobody had checked.

find . -iname '*openapi*' -not -path '*/node_modules/*'
02

See what it would produce

Writes nothing. If the surface comes back mostly reads, your API is the limit, not the generator.

git clone https://github.com/alibad/openapi-mcp
cd openapi-mcp && npm install && npm run build
node dist/cli.js inspect ../your-app/docs/openapi.yaml
03

Mark what must never be a tool

Four booleans in the spec, next to the API definition instead of in a parallel server that drifts. Credentials, account deletion and OAuth callbacks are never tools.

/v1/goals:
  post:
    operationId: createGoal
    description: Create a goal. Say what it does
      AND what it does not.
    x-mcp-idempotent: true
  delete:
    x-mcp-ignore: true
04

Boot it before believing it

A file that typechecks can still publish a surface no client accepts. One bad output schema makes the SDK reject everytool on the server.

node dist/cli.js generate --config openapi-mcp.config.json
node scripts/verify-generated-server.mjs ../your-app/mcp

The generator is the easy half. Writing the descriptions is the work — 42 of DoneOS’s operations had none, so every tool published its own operationId back at the model. The rules for that live in the skill, next to the generator.

Where the human stays

Useful access is deliberately bounded.

Connect a client

Use a throwaway token. Get a fresh fictional board.

Connect directly to the Human Quest MCP endpoint. Each throwaway token creates an isolated fictional board for the live proof.

mcp.humanquest.net live and write/read-back verified
{
  "mcpServers": {
    "doneos-demo": {
      "type": "http",
      "url": "https://mcp.humanquest.net/api/mcp/doneos",
      "headers": {
        "Authorization": "Bearer pick-a-demo-string"
      }
    }
  }
}
See the 23 tools this demo exposes — 16 of them writes, every one generated from DoneOS’s OpenAPI spec
Part of Human Quest · humanquest.net