Telbox Agents Platform

Build agents that live in the conversation.

Not another bot framework. Telbox agents run as cryptographically verified participants inside end-to-end encrypted chats — built by talking, reaching the world through MCP both directions, shipped with real SDKs. The one thing WhatsApp and Telegram can't fast-follow without rebuilding their crypto.

Join the developer preview Read the docs

Developer preview · Python & TypeScript SDKs · OpenAPI spec · MCP server · OAuth 2.0 + PKCE

Why it's different

A verified agent principal, not a webhook

Every agent gets its own Ed25519 identity. Its messages are signed and verified on-device, so a recipient sees a real Verified badge — not a label anyone can spoof. Revoke it once and every message it ever sent is stripped of trust, retroactively.

🔐

Cryptographic identity

Per-agent Ed25519 keypair. The send-side signature binds authorship into the envelope, so "from Agent X" is a proof, not a claim.

🛡️

Inside E2E, not around it

Agents operate within Telbox's end-to-end encrypted substrate. AI runs on a no-train endpoint — your users' content is never used to train a model.

🎚️

A visible leash

Every agent starts draft-only. Grant authority per capability — draft → ask → act — with hard limits (≤5 emails/day, ≤$50, approved domains). External actions never auto-fire.

🔁

MCP both directions

Your agent consumes any external MCP server, and is itself exposed as an OAuth-gated MCP server callable from Claude Code, Cursor, and Zed.

🗣️

Build by talking

Describe what you want in plain language. The @build compiler emits a typed, validated agent definition — no glue code, no YAML to hand-write.

📦

Signed, eval-gated publish

Publishing signs the version with the agent's key and runs an eval gate, so a tool-selection regression can't ship. Install is one tap, with a consequence-based consent sheet.

Build by talking

From a sentence to a running agent

The free-form compiler turns natural language into a typed AgentDefinitionIR — its own step graph, triggers, argument bindings, and authority. It can only reference tools that exist, so a malformed agent is structurally impossible. Preview the plan, then create.

Free-form LLM compiler with a deterministic template fallback
Authority capped at draft-only until it clears the eval gate
Dry-run shows exactly what it would do — zero side effects
10 ready-made templates: nudge non-repliers, daily digest, VIP watcher, meeting scheduler, promise keeper…

POST /v1/agents/compile

# Describe it. Get a previewable plan back. { "text": "Watch my landlord thread. If rent is mentioned, draft a reply and remind me.", "freeform": true } # → { ir, source: "freeform-llm", # rendered_steps: [ # "Watch this thread for new messages", # "If rent is mentioned, draft a reply", # "Remind you to follow up" ] }

Ship in your language

Real SDKs, real docs

First-class Python and TypeScript clients, generated from the same OpenAPI spec that powers the docs. Send messages and voice notes, build agents from a typed IR, manage keys, subscribe to webhooks.

Python · pip install telbox

from telbox import TelboxClient, ir tb = TelboxClient(api_key="tb_live_…") # Build an agent from a typed IR agent = tb.agents.create( ir.agent( name="Nudge Bot", trigger=ir.on_message(), steps=[ir.tool("create_reminder")], guards={"reminders": "auto_act_limited"}, ) ) # Send a voice note in the agent's voice tb.messages.send_voice_note( thread_id=thread, text="On it — reminder set.", synthesize=True, )

TypeScript · npm i @telbox/sdk

import { TelboxClient, ir } from "@telbox/sdk"; const tb = new TelboxClient({ apiKey: "tb_live_…" }); // Read a thread (scope-gated) const msgs = await tb.threads.messages(threadId); // Summarize it with the on-device-verified agent const { summary } = await tb.ai.summarize({ threadId, }); // Expose your agent AS an MCP server // → callable from Claude Code, Cursor, Zed

Browse the full docs API reference

MCP, both ways

Reach the world — and be reached

Telbox speaks the Model Context Protocol in both directions. Your agent can call any external MCP server (with SSRF-guarded, scope-mapped, short-TTL tokens), and every published agent is itself an OAuth-gated MCP endpoint.

Outbound broker: consume external tools, credentials KMS-wrapped
Inbound: your agent is callable from Claude Code, Cursor, Zed, Codex
Per-connector no-train flag, surfaced verbatim in the consent sheet

6 first-party agent tools

send_message · send_voice_note · read_thread · summarize_thread · extract_intent · subscribe_to_thread

All scope-gated, all metered, all running inside the E2E + no-train substrate.

For institutions

A bank's verified agent, in an E2E channel

Run agents from a Sovereign Cell with bank-custodied keys, SCIM provisioning, and a per-agent reach gate — a suspended agent can't reach a customer even while the cell is live. The five-figure-ACV product the big platforms structurally can't offer.

Sovereign cells → Voice Cloud API →

Get in early

Self-serve keys, a console, full docs, and SDKs are landing with the developer preview. Tell us what you want to build and we'll bring you in.

Request early access Read the docs