OttoIdentity
NewAgent inboxes are live

Give your agents
a real identity.

An email address, durable memory, a project board and a browser — for every agent you run. One API key turns a language model into a coworker that can actually receive, remember and follow through.

Create your first agentRead the API
otto@ottoidentity.com
ottoidentity.com/mail

Otto Research

otto@ottoidentity.com

2

  • Dana Whitfield

    2m

    Re: Q3 vendor shortlist

    Thanks for pulling this together so fast. Two questions on the pricing table…

  • billing@northwind.io

    18m

    Invoice #4471 attached

    Your monthly statement is ready. Total due $2,480.00 by 15 August.

  • Marcus Lee

    1h

    Intro — Otto ↔ Helios data team

    Connecting you two. Marcus, Otto handles our research ops now.

  • notifications@github.com

    3h

    [otto-core] 3 checks failed on #218

    The typecheck job failed on node 22. See the run summary.

Drop into any agent stack — it's just HTTP

Claude Agent SDKLangChainLangGraphVercel AI SDKCrewAIOpenAI Agentsn8nMastraPydantic AIcurl

Capabilities

Everything an agent needs to do real work

Most agent frameworks stop at the model call. OttoIdentity is the layer underneath — the durable, addressable, accountable parts.

Email

Live

Every agent gets a real, deliverable inbox on your domain — powered by Mailgun. It sends, receives, threads replies and handles attachments.

  • Inbound webhooks parsed into threaded conversations
  • SPF, DKIM and signed webhook verification
  • Reply-aware headers so threads never fork
See the API

Project management

Live

A board your agents and your team share. Agents open tasks, move them across columns and comment as themselves.

  • Per-project task keys like OTTO-142
  • Assign work to an agent or a human

Memory

Live

Durable recall that survives the context window. Write a fact once, retrieve it ranked by relevance and importance forever.

  • Full-text and fuzzy retrieval in one call
  • Scoped per agent or shared across your fleet

Browser

Beta

Give an agent a page to read. Navigate, extract clean text and capture structured output through a session it can resume.

  • Readable text extraction, not raw HTML soup
  • Every action logged and replayable

Cron jobs

Coming soon

Wake an agent on a schedule. Nightly digests, Monday standups, hourly inbox sweeps — without you hosting a scheduler.

  • Cron expressions with timezone support
  • On the way this quarter

How it works

From zero to a working agent in three steps

  1. 01

    Name your agent

    Pick a name and a handle. Otto provisions the inbox, the memory store and the API key in one step.

  2. 02

    Hand it the key

    Drop OTTO_API_KEY into your agent's environment. Every capability is reachable from that one credential.

  3. 03

    Let it work

    Mail arrives in a threaded inbox, facts persist across runs, tasks land on a board your team can see.

agent.ts
import Anthropic from "@anthropic-ai/sdk"

const otto = ottoClient(process.env.OTTO_API_KEY!)

// 1. What has this agent been told before?
const { memories } = await otto.searchMemory(email.subject)

// 2. Decide what to do.
const reply = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: prompt(email, memories) }],
})

// 3. Act as itself — send, remember, follow up.
await otto.sendMail({ to: [email.from], text: reply.text })
await otto.remember({ kind: "event", content: summary })
await otto.createTask({ project: "OTTO", title: followUp })

Developers

One key. One REST API. No SDK required.

Every capability is a plain HTTP endpoint scoped to an agent by its API key. If your agent can call fetch, it can send mail, remember a fact and file a task.

Bearer auth
Keys are SHA-256 hashed at rest and shown exactly once.
Agent-scoped
A key bound to an agent can only ever act as that agent.
Predictable errors
Typed error bodies with per-field validation details.
Works anywhere
LangChain, the Claude Agent SDK, a cron script, curl.
send.ts
// Your agent replies to a customer, as itself.
const res = await fetch("https://ottoidentity.com/api/v1/mail/send", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OTTO_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    to: ["dana@northwind.io"],
    subject: "Re: Q3 vendor shortlist",
    text: "Onboarding is included in the Helios quote.",
    in_reply_to: "<CADx...@mail.gmail.com>",
  }),
})

const { message } = await res.json()
// → { id, thread_id, status: "sent" }

Pricing

Priced per fleet, not per seat

Your agents aren't people, so we don't charge like they are. Every plan includes the full API — the tiers differ only in how much your agents can do.

Starter

One agent doing real work, end to end.

$20/month
Start with Starter
Agent inboxes
3
Emails sent /mo
1,000
Memories stored
2,500
Browser sessions /mo
250
  • Shared project boards
  • Full REST API and SDK
  • Email support
Most popular

Growth

A small fleet handling live customer mail.

$30/month
Start with Growth
Agent inboxes
10
Emails sent /mo
5,000
Memories stored
25,000
Browser sessions /mo
1,500
  • Everything in Starter
  • Custom sending domain
  • Priority email support

Scale

Production agents with volume to match.

$50/month
Start with Scale
Agent inboxes
30
Emails sent /mo
20,000
Memories stored
100,000
Browser sessions /mo
6,000
  • Everything in Growth
  • Audit log export
  • Cron jobs at launch

Enterprise

Custom limits, controls and paperwork.

Custom
Contact us
Agent inboxes
Unlimited
Emails sent /mo
Unlimited
Memories stored
Unlimited
Browser sessions /mo
Unlimited
  • Everything in Scale
  • SSO and SCIM
  • Data residency options
  • SLA and named support

Every account starts free with 1 inbox so you can build before you pay. Monthly counters reset on the first of each month.

FAQ

Questions, answered

Where does the email actually come from?

Mailgun. You point an MX record at OttoIdentity, we handle SPF, DKIM and inbound routing, and every agent gets a deliverable address on your own domain. Outbound goes through your Mailgun account, so reputation and logs stay yours.

Is memory a vector database?

Not by default. Memory is Postgres full-text search combined with trigram similarity, ranked by relevance and importance. That handles recall well without an embedding bill or a second datastore. If you want semantic search, the schema has room for an embedding column.

Can humans use the project board too?

Yes — that's the point. Agents and people share one board. When an agent files OTTO-142, your team sees it in the same column as everything else, with the agent named as the author.

What stops an agent from acting as a different agent?

API keys are bound to a single agent at creation. A scoped key rejects any request naming another identity. Account-wide keys exist for orchestrators, and they must name the agent explicitly on every call.

When are cron jobs shipping?

This quarter. The schema and UI are already in the product behind a 'coming soon' state, so scheduled wake-ups will light up without a migration on your side.

Do you train on our data?

No. Your mail, memories and tasks are yours. We don't read them, and we don't use them to train anything.

Your agent is ready.
It just needs an address.

Spin up an identity in under a minute. Free while you build, no card required.

Start freeBrowse the docs