for the agents you ship

Your agent shouldn’t write the proposal. It should fill one.

An AI SDR, a website consultant, a voice agent after the call, an n8n flow — give it a human-approved template with a field schema. It sends a few values and gets back a live, personalized, tracked page for the prospect. Deterministic, on-brand, a few hundred tokens.

rest api on every plan · no per-call fees · agents don’t take seats

your agent → naimi api
› discovery call with Northwind done — send the proposal

POST /api/presentations
{
  "templateId": "tpl_web_proposal",
  "client": { "companyName": "Northwind", "contactName": "Maya" },
  "personalization": {
    "scope": "Website redesign, 6 weeks",
    "price": 12400,
    "deadline": "2026-09-18"
  }
}

201  shareUrl: https://app.naimi.ai/northwind-k3x9
✓ sent to maya@northwind.com
✓ 14:32 presentation.opened — Northwind · viewing now
why fill, not write

An agent can generate a whole document. That is exactly the problem.

01

Off-brand is a liability

Free-form generation puts a document nobody approved in front of a customer — wrong price, invented terms, someone else’s tone. With Naimi the skeleton is human-built; the agent can only change the fields marked as personalizable, and the server rejects anything else.

Forrester’s 2026 B2B predictions put the cost of ungoverned generative AI in go-to-market applications above $10 billion. Source ↗

02

Tokens: hundreds, not thousands

Generating a twelve-slide deck is thousands of output tokens plus the brand guide, prior decks and examples in context — every time, for every prospect. Filling six fields against a 200-token schema is a few hundred tokens. Roughly thirty times fewer on output alone, before latency.

Our arithmetic at current list prices; a per-document cost you can predict before writing code.

03

A file is a dead end. A link reports back.

A generated PDF leaves the agent blind. A Naimi link returns opens, view time, a live “viewing now”, the client’s own answers — and a signed webhook the moment it is opened — so the agent follows up on signal, not on a timer.

Everything the sales team sees in the app, the agent sees through the API.

the loop

Three calls. Schema, values, link — then the signal comes back.

The template’s manifest is the contract: field keys, types and which are required. Your agent returns exactly that shape — the same way it already produces structured output.

1 · read the schema

GET /api/templates/tpl_web_proposal
Authorization: Bearer <scoped token>

200 {
  "template": {
    "id": "tpl_web_proposal",
    "manifest": {
      "personalization": {
        "fields": [
          { "key": "company",   "type": "text",     "required": true  },
          { "key": "contact",   "type": "text",     "required": true  },
          { "key": "scope",     "type": "textarea", "required": true  },
          { "key": "price",     "type": "number",   "required": true  },
          { "key": "deadline",  "type": "date"                        },
          { "key": "hero_image","type": "image"                       }
        ]
      }
    }
  }
}

2 · send the values, get the link

POST /api/presentations
{
  "templateId": "tpl_web_proposal",
  "client": { "companyName": "Northwind", "contactName": "Maya" },
  "personalization": {
    "company":  "Northwind",
    "contact":  "Maya",
    "scope":    "Website redesign, 6 weeks, 3 rounds",
    "price":    12400,
    "deadline": "2026-09-18"
  }
}

201 {
  "presentation": {
    "id": "prs_k3x9",
    "shareUrl": "https://app.naimi.ai/northwind-k3x9",
    "stats": { "openCount": 0, "totalViewSeconds": 0 }
  }
}

3 · the signal comes back

POST https://your-agent.example/naimi
X-Naimi-Signature: sha256=…

{
  "event": "presentation.opened",
  "presentationId": "prs_k3x9",
  "client": "Northwind",
  "openCount": 1
}

…and on the presentation itself: openCount · uniqueVisitorCount · lastOpenedAt · totalViewSeconds · activeViewerCount · clientResponses. Deal status is one more call.

every noun is an endpoint

The whole sales loop, as tools.

REST today; an open-source skill file teaches any agent the API in one read. MCP server in progress.

Templates

  • List published templates
  • Read a template’s field schema and slide index

Presentations

  • Create from a template with field values — live at once
  • Update personalization on a live link
  • Pre-seed interactive values; set deal status
  • Read stats and the client’s own answers

Clients & memory

  • Create or reuse a client inline
  • Read and write facts that pre-fill the next document

Signals & access

  • HMAC-signed webhooks on open; Telegram alerts for humans
  • Scoped, expiring API tokens — one per agent

Machine-readable by default: every page on this site is also served as Markdown (append .md), the site index is at /llms.txt, and the agent skills are open on GitHub.

three recipes

Where it slots into what you already run.

ai sdr · after the discovery call

Transcript in, proposal link out

  1. Agent maps the transcript to the template’s six fields
  2. POST /api/presentations → shareUrl
  3. Sends the link in the follow-up email
  4. Webhook on open → agent follows up while it’s on their screen

website consultant · at qualification

The chat ends with a personal offer page

  1. Site agent qualifies the visitor and collects the inputs
  2. Creates the client and the presentation in one call
  3. Hands over the link inside the chat
  4. The rep sees “viewing now” while the visitor is still on the site

n8n · make · zapier

Form → LLM → link → Telegram

  1. Form node collects the brief
  2. LLM node returns JSON constrained to the field schema
  3. HTTP node posts it to Naimi, gets the link
  4. Telegram node pings the team on first open

Building templates with your own coding agent — Claude Code, Cursor, Codex — is a different page: Build with your agent →

faq

What agent builders ask.

Who builds the template — the agent or us?

Your team does, once — in Naimi Studio or with your own coding agent — and marks which parts may change per client. The external agent only fills those parts. That split is the whole idea: the persuasion, brand and layout are approved by a human; the agent supplies the client-specific values and never touches anything else.

What happens if the agent sends bad data?

The server rejects it. Required fields missing → 400 with the list of what’s missing; fields the template does not declare are ignored unless the template explicitly allows custom fields. Types are declared in the schema — text, long text, number, date, image — so the agent knows what to produce, and the presentation renders exactly like every other one from that template.

Is there an MCP server?

In progress. Today the surface is the REST API, plus an open-source skill file that teaches any agent the whole API in one read — paste it into your agent’s context and it knows how to list templates, create and edit presentations, read stats and write client memory. Claude Code, Codex, Cursor and custom agents use it as is.

Can the agent change a presentation after it was sent?

Yes — the link never changes. Update the personalization, pre-seed interactive values (a selected package, a slider position), or set the deal status; the client’s next open shows the current version.

What does the agent get back after the send?

Opens, unique visitors, last opened, total view time and a live “viewing now” count on the presentation object; everything the client typed or picked in self-fill fields; and an HMAC-signed webhook the moment the link is opened. Facts about the client accumulate on their card and pre-fill the next document for them, from any template.

How is access controlled?

Scoped API tokens: grant only what the agent needs — read templates, write presentations, write clients — with an expiry, and revoke in one click. One token per agent is the recommended shape. Tokens are stored hashed and shown once.

What does it cost per document?

Nothing per call. The API is on every plan, Free included; a presentation created by an agent counts against the plan’s monthly presentation quota exactly like one created by a person — 30 on Free, 100 on Pro, unlimited on Business. Credits are never involved: creating a presentation is field filling, not AI generation. Agents don’t take seats.

Does the recipient need an account?

No. The link opens in any browser with no login, no download — which is why it can be handed over inside a chat, an email, an SMS after a call, or a checkout flow.

Give your agent a document it can’t get wrong.

Free plan, API included, no card. Build one template today; let the agent fill it for every prospect tomorrow.

4.7/5 · 500+ customers free plan · no credit card · cancel anytime