When an agent decides to do something (notify a customer, trigger a workflow, update a system), that action can silently fail. Route it through Mittr over MCP and it gets retried, dead-lettered, replayed, and audited. Reasoning is solved; acting isn't.
Mittr exposes a remote MCP server. Give any MCP-speaking agent the URL and your API key. It discovers the tools and calls them itself. No per-tool glue, no parallel SDK.
import Anthropic from "@anthropic-ai/sdk";
const claude = new Anthropic();
// Point Claude at Mittr's MCP server; your Mittr API
// key is the Bearer token the endpoint authenticates.
const message = await claude.beta.messages.create({
model: "claude-opus-4-8",
max_tokens: 1024,
betas: ["mcp-client-2025-11-20"],
mcp_servers: [{
type: "url",
name: "mittr",
url: "https://app.mittr.io/mcp",
authorization_token: process.env.MITTR_API_KEY, // mtr_...
}],
tools: [{ type: "mcp_toolset", mcp_server_name: "mittr" }],
messages: [{
role: "user",
content: "Send an order.created event through Mittr, " +
"then tell me if it was queued for delivery.",
}],
});
// Claude calls mittr_send_event itself — no per-tool glue.
// The action is retried, dead-lettered, and audited for free.from anthropic import Anthropic
import os
claude = Anthropic()
message = claude.beta.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
betas=["mcp-client-2025-11-20"],
mcp_servers=[{
"type": "url",
"name": "mittr",
"url": "https://app.mittr.io/mcp",
"authorization_token": os.environ["MITTR_API_KEY"], # mtr_...
}],
tools=[{"type": "mcp_toolset", "mcp_server_name": "mittr"}],
messages=[{
"role": "user",
"content": "Send an order.created event through Mittr, "
"then tell me if it was queued for delivery.",
}],
)
# Claude discovers Mittr's tools over MCP and calls them itself.{
"mcpServers": {
"mittr": {
"url": "https://app.mittr.io/mcp",
"headers": {
"Authorization": "Bearer mtr_your_key"
}
}
}
}An agent fires an HTTP call, it fails, and the side effect is silently lost. That's the exact problem Mittr already solves, now applied to what your agent does.
is how often the best frontier agent solves the identical task 8 tries out of 8. Deciding right once is not the same as landing the action every time. Sierra tau-bench, pass^8
Tool use is fragile: small deviations in arguments trigger failures that propagate through the toolchain, even when the high-level intent is correct. arXiv:2607.05775
LangGraph, CrewAI, and Google ADK re-run pre-interrupt code on resume, firing the same action twice. Pass an agentRunId and Mittr derives the idempotency key from the run and the action itself, so the replay deduplicates without you having to think about it. Durable-execution research
Connect over MCP and an agent can set up endpoints, send events, and inspect or replay deliveries, the same operations your code gets, exposed as tools it can call.
A side effect stops being a fire-and-hope HTTP call. Every send gets the same backoff, circuit breakers, and dead-letter recovery as the rest of your traffic.
Events are correlated by agent run and fully logged, so you can see exactly what an agent did, and replay any delivery when it needs a second attempt.
Every tool calls the exact service the REST API uses, so an agent inherits the whole delivery engine: outbox, backoff, circuit breakers, dead-letter, audit. Tools and their fields are self-describing and the server ships usage instructions on connect, so agents call them correctly out of the box. Mittr sits at the action boundary, not inside your runtime, so there is nothing to rewrite: point any MCP client at it, and receive A2A push notifications (authenticated webhooks between agents) the same reliable way. It works alongside or on top of any agent framework, LangGraph, CrewAI, the OpenAI Agents SDK, even Temporal, so you add the reliable action boundary without replacing your runtime. Read-only tools are marked so hosts can auto-approve them.
Grab a free API key, point your agent at the MCP endpoint, and its next action gets retried until it lands, and logged either way.