The secure handoff layer for AI agents

Create a kubbi, get a claim URL, and let the next agent or human claim it on their own schedule. One link, one TTL, one burn policy.

Get started free Read the docs

const client = new KubbiClient({ apiKey })
const { claimUrl } = await client.sendFiles({
  files: [
    { name: "config.json", content, contentType: "application/json" },
    { name: "data.csv",    content, contentType: "text/csv" },
    { name: "report.md",   content, contentType: "text/markdown" },
  ],
  ttlSeconds: 3600,
  maxRetrievals: 1,
})

Built for the handoffs you've been duct-taping

Different actors, different timing, sensitive payloads, or multiple files in one package - kubbi gives the handoff a cleaner pattern.

Different actors

The producer and consumer are different agents, workflow steps, teams, or humans.

Different timing

The next actor may claim the payload later, not immediately.

Sensitive or temporary data

The payload is sensitive, large, or short-lived - not something you want inline.

Multiple files in one handoff

Config, data, instructions, and attachments - bundle up to five files in a single claim link.

How kubbi works

A producer creates a kubbi, the workflow carries only the claim URL, and the consumer picks up the payload on their own schedule.

Agent A

A producer creates a kubbi with a payload or file bundle, a TTL, and an optional retrieval limit.

claim URL

The workflow carries only the claim URL - through MCP, A2A, queues, or task systems.

Agent B

The consumer claims the payload on their schedule. kubbi expires or burns it after.

The payload stays in kubbi. Only the claim URL travels.

Temporary by design, controlled by default

Set expiry, read limits, and burn behavior at the kubbi level so agents can pass data with clearer boundaries and less exposure in the workflow.

Encrypted at rest

Every payload is AES-256 encrypted before it touches storage. Keys rotate automatically.

TTL expiry

Set a time-to-live and the payload self-destructs - no stale data, no cleanup scripts.

Burn after read

One claim, one read, gone forever. Perfect for secrets, tokens, and one-time handoffs.

Multi-file packages

Bundle up to five files in a single kubbi. One claim link delivers config, data, instructions, and attachments together.

Inspect before claim

Preview metadata and file manifests without consuming the payload so you know what you’re getting.

Delete early

Changed your mind? Revoke a kubbi before it’s claimed — the producer stays in control.

Designed for easy integration

First-class SDKs for Python and TypeScript, native MCP tool support, and a clean REST API. Pick the path that fits your stack.

Python SDK

pip install kubbi and start creating handoffs in three lines. Async-ready with full type hints.

python

from kubbi import KubbiClient

client = KubbiClient(api_key="kb_...")
result = client.send(
    content="sensitive data",
    content_type="text/plain",
    ttl_seconds=3600,
)

TypeScript SDK

npm install @kubbi.ai/sdk — tree-shakable, zero dependencies, works in Node, Deno, and edge runtimes.

typescript

import { KubbiClient } from "@kubbi.ai/sdk";

const client = new KubbiClient({ apiKey: "kb_..." });
const result = await client.send({
  content: "sensitive data",
  contentType: "text/plain",
  ttlSeconds: 3600,
});

MCP Integration

Expose kubbi as a tool inside any MCP-compatible agent. Agents create, claim, and send multi-file packages natively.

json

{
  "tool": "kubbi_send",
  "arguments": {
    "content": "result-data",
    "contentType": "application/json",
    "ttlSeconds": 3600,
    "maxRetrievals": 1
  }
}

REST API

A single POST to create, a POST to claim. Standard HTTP — no SDKs required, works from any language or platform.

bash

curl -X POST https://api.kubbi.ai/api/v1/kubbis \
  -H "Authorization: Bearer kb_..." \
  -H "Content-Type: application/json" \
  -d '{
    "content": "secret",
    "content_type": "text/plain",
    "ttl_seconds": 3600
  }'

Explore the docs

Works with the tools you already use

kubbi doesn't replace anything in your stack. It sits alongside your existing channels so they carry a claim URL instead of the payload.

MCP tool resultA2A messageWorkflow orchestratorQueue messageWebhook payloadShared task or ticket

Try kubbi on your next workflow

Create a temporary handoff, pass one claim URL, and let the next agent or human pick it up when ready.

Get Started Free