The missing primitive: how AI agents talk to humans for context.

Your agents query a structured, provenance-aware graph of what humans in your org know. When the graph has a gap, Delvry harvests it from the right humans and writes the answer back. Works with Claude Code, Cursor, Cline, or any MCP-speaking agent.

Or programmatically — see below.

$ curl -X POST https://delvry.ai/v1/accounts/signup     -H "content-type: application/json"     -d '{"email":"agent@example.com","account_name":"My project"}'

{ "account_id": "...", "first_api_key": "delvry_sk_...", "password_generated": true }

#Overview

Delvry is the I/O and memory layer between AI agents and human knowledge. Agents query a structured graph of claims — typed assertions about entities (policies, people, products) with confidence, provenance, and decay. When the graph has the answer, the agent gets it back in milliseconds. When it doesn't, Delvry harvests the gap from the right humans, writes the answer back, and the next agent finds it waiting.

Three surfaces: the MCP server (the only thing your agents talk to), /app (operator dashboard — view the graph, approve harvests, audit provenance), and the harvest form humans see when an agent asks them something. Surveys were the wedge. The graph is the product.

Delivery is your call: Delvry emails each person their link by default, or pass notify:false and the API hands you the per-recipient links to route however you like — Slack, Teams, SMS, a doc. The graph and provenance work the same either way.

Built for the forward-deployed engineer, the solutions architect, the AI operator dropped into a business they don't know yet — whose real job is to get the tribal knowledge out of a dozen people's heads (clinical ops, RCM, sales, support) and into something an agent can use. Point Delvry at the domain, it asks the right people the right questions, reconciles where they disagree, and converges the whole team on one canonical source of truth — autonomously. Stop running interview marathons and pasting notes into a doc.

#What it does

#Under the hood

The graph doesn't just store what people said — it reasons about how much to trust it, asks the right human next, and refuses to guess when it doesn't know. 46 MCP tools; here's the part that makes the answers worth acting on.

#Using Delvry from Claude Code

Drop a .mcp.json in your project root. Claude Code picks it up on the next session.

{
  "mcpServers": {
    "delvry": {
      "url": "https://delvry.ai/mcp",
      "headers": { "Authorization": "Bearer $DELVRY_API_KEY" }
    }
  }
}

Claude Code is building a Shopify refund integration. It needs to know what counts as fraudulent. Instead of guessing or interrupting you, it calls delvry_query("fraud criteria for refunds"). If the graph already knows, Claude Code gets back a structured claim with confidence and sources. If not, delvry_ask_humans pings the right stakeholders; the agent subscribes for an update and continues working on independent parts. Hours later, the answer comes back with provenance — and stays in the graph for next time.

Get an API key →

#Install

One paste, any Claude. The MCP server bootstraps its own API key on the agent's first delvry_signup call — no manual key-swap.

$ claude mcp add delvry -e DELVRY_API_KEY=$DELVRY_API_KEY -- npx -y @delvry/mcp

{
  "mcpServers": {
    "delvry": {
      "command": "npx",
      "args": ["-y", "@delvry/mcp"],
      "env": { "DELVRY_API_KEY": "$DELVRY_API_KEY" }
    }
  }
}

$ https://delvry.ai/mcp

$ mkdir -p .claude/skills/delvry && \
    curl -fsSL https://delvry.ai/skill.md > .claude/skills/delvry/SKILL.md

# bootstrap (saves key to ~/.delvry/config.json)
$ npx -y @delvry/cli signup
> ✓ Account created. account_id=...
> ✓ API key saved to ~/.delvry/config.json (chmod 0600)

# non-interactive (CI)
$ npx -y @delvry/cli signup --email agent@example.com \
    --account-name "My project" --yes

$ npx -y @delvry/cli surveys list

$ curl -X POST https://delvry.ai/v1/accounts/signup \
    -H "content-type: application/json" \
    -d '{"email":"agent@example.com","account_name":"My project"}'

{ "first_api_key": "delvry_sk_...", ... }

$ curl -X POST https://delvry.ai/v1/surveys \
    -H "Authorization: Bearer $DELVRY_API_KEY" \
    -H "content-type: application/json" \
    -d @retro.json

Agents: machine-readable install at /llms.txt. Protocol: /protocol/openapi.yaml (draft OpenAPI spec). Skill bundle: /skill.md.

#Survey schema

Nine question types: short_text, long_text, single_choice, multi_choice, number, yes_no, scale, ranking, date. Plus boolean toggles, Likert scales, click-to-rank, and date inputs. Branching via show_if. Pages auto-skip when every question is hidden. Required fields, min/max, default values, and per-question validation are all declared in the DSL.

{
  "version": "1",
  "title": "Q1 retro",
  "pages": [
    { "questions": [
      {
        "id": "role",
        "type": "single_choice",
        "prompt": "What's your role?",
        "required": true,
        "options": ["Eng", "Design", "PM"]
      }
    ] }
  ]
}

#Pricing

Live machine-readable catalog: GET /v1/plans.

#Changelog

# shipped milestones · newest first

#FAQ

How is this different from MCP servers I already have?

MCP servers connect agents to systems (Stripe, Slack, your DB). Delvry connects agents to humans — the people who hold context that isn't written down anywhere. It's a different primitive: not retrieval, but harvest.

Does it work with Cursor / Cline / [other agent]?

Yes. Delvry is a Streamable HTTP MCP server. Any MCP-speaking client works. Claude Code is the canonical example because we test against it; Cursor / Cline / custom agents work identically.

What is a "claim"?

A structured assertion about an entity (refund policy, founder intent, the support team) with a confidence score (0–1), a decay class (principle / policy / process / tactical / transient), and provenance — who said it, when, with what supporting quote.

Why a graph? Why not just embeddings?

Embeddings give you similarity. Claims give you assertions with confidence and provenance. We use embeddings for retrieval inside the graph — the graph itself is the queryable layer of structured knowledge.

What's the stack?

Cloudflare Workers (edge), D1 (SQLite for entities, claims, sources), Vectorize (semantic search), Workers AI bge-base for embeddings, and Anthropic Claude Haiku for claim extraction. Hono on the routing layer.

Why not just have the agent ask in chat?

Chat is great for one person, one question, one time. Once you need an answer that persists, gets cited, decays, and is reused by the next agent — you need a graph. Delvry is that graph.

What's the recipient experience like?

Mobile-first form, no login, autosaved on every keystroke, branded with your accent color and logo. Preview an example →

How is data stored?

Cloudflare D1 (SQLite-on-the-edge) and KV in iad-1 (us-east) by default. Encrypted at rest by Cloudflare's storage layer; TLS terminated at the edge. Recipient PII is purged 90 days after survey close; claim retention is tier-dependent (see /v1/plans). Full details: /security.

#Delvry vs. alternatives

# why not just use a form builder, Slack, or roll your own?

#Get started

Built by David, solo founder. Delvry (rhymes with "deliver-y") is bootstrapped and founder-handled — email hello@delvry.ai and you'll reach the person who wrote the code.

© 2026 Delvry · privacy · terms · security · brand · protocol · llms.txt · github · made for agents, by humans