Tutti is in early preview — APIs may change before 1.0. We'd love your feedback — open an issue on GitHub →
Open-source · early preview · Apache 2.0

The TypeScript agent framework that treats production seriously.

Sixteen official voices, 116 tools, an inbox that reaches users on Telegram / Slack / Discord / email / WhatsApp, scheduled jobs that deliver their reply on the same channels, self-improving skills synthesised from observed trajectories, destructive operations gated by default, a smart router that picks the cheapest model per turn, hard cost budgets, and one-command deploys to Docker, Railway, Fly, Modal, and Daytona. The plugin ecosystem is the framework.

Apache 2.0 TypeScript Node 24+
~/my-agent
$ npm install -g tutti-ai
$ tutti-ai init my-agent
$ tutti-ai run -p "Refactor this function to be more performant"
→ routed to claude-sonnet-4-6 (tier=medium) — code request
→ output: Here's the refactored version…
Production ship

From tutti-ai run to a containerised service in one command.

Smart routing

Cheapest model per turn

Drop a SmartProvider into your score. Every turn classified, dispatched to the right tier. Destructive-tool aware. Budget-aware. No SaaS gateway.

How it works →
Cost budgets

Hard caps. Per run, day, month.

max_cost_usd_per_day throws BudgetExceededError. tutti-ai analyze costs shows top runs, daily sparkline, optimisation hints.

Deploy

Docker / Railway / Fly in one command

tutti-ai deploy --target railway. Pre-flight secrets scanner blocks plaintext API keys. deploy status / logs / rollback wraps the platform CLI.

Deploy guide →
After the demo

Agents that learn. Schedules that deliver. Serverless that wakes up.

@tuttiai/skills turns repeated tool sequences into operator-reviewed skills the agent calls as one tool. Schedules deliver their reply to Slack, email, Discord, Telegram, or WhatsApp. And tutti-ai deploy --target modal ships scale-to-zero in one command — with a verify-hibernate precheck so cold starts don't drop state on the floor.

tutti.score.ts
export default defineScore(({
agents: {
standup: {
schedule: {
cron: '0 9 * * 1-5',
input: 'Summarise yesterday',
deliver: { platform: 'slack', channel: '#standup' },
deliver_format: 'markdown',
},
},
},
skills: { enabled: true, auto_propose_threshold: 5 },
})
$ tutti-ai deploy --target modal
→ verify-hibernate: ✓ no long-lived in-memory state
→ modal app deployed · scale-to-zero · cold-start ~9s
Since v0.25

One agent. Every channel.

@tuttiai/inbox wires Telegram, Slack, Discord, email and WhatsApp to one agent. Allow-list, per-user rate limit, per-chat queue, and identity linking applied uniformly above the adapter.

tutti.score.ts
inbox: {
agent: 'support',
adapters: [
{ platform: 'telegram' },
{ platform: 'slack' },
{ platform: 'discord' },
{ platform: 'email', ...EMAIL },
{ platform: 'whatsapp', phoneNumberId },
],
},
Live run · routing decision on every turn

Every turn, the cheapest model that can handle it.

Each call is classified by content, dispatched to the right tier, and emitted as a span — so you can audit every routing decision and every dollar.

routed budget-aware destructive-aware logged
~/my-agent
Why Tutti

Built like real software. Not like a prompt hack.

tutti.score.ts

Declare once, run anywhere.

Your whole agent system in one typed file. Reviewed in PRs, versioned with your code.

// tutti.score.ts
import { defineScore } from '@tuttiai/core'

export default defineScore(({
  agents: {
    reviewer: {
      voice: 'github',
      model: 'claude-opus-4-7',
      guardrails: ['read-only', 'no-secrets'],
    },
  },
})
Type-checked at edit time.

Guardrails that actually run.

Secret redaction, path sandboxing, prompt-injection filters, per-voice permissions. Enforced at the runtime boundary, not in a README.

redact-piino-writesallowlist-toolsmax-tokenstimeoutescalate-low-confidence
Official voices
16
+ MCP bridge for the rest
Tools shipped
116
all Zod-validated, no any

Swap models in one line.

Claude, GPT, Gemini, Llama, Mistral, OpenAI-compatible endpoints. No vendor lock-in, ever.

claude
gpt
gemini
llama
Observability

Every step is a span.

OTEL out of the box. Replay any run, diff any output, export to your warehouse.

planner delegate → coder · 120ms
coder tool.call github.openPR · 840ms
qa tool.call playwright.run · 3.1s
✓ done total · 18.4s

MCP bridge built-in.

Install @tuttiai/mcp and wrap any Model Context Protocol server as a typed Tutti voice. Tools auto-discovered, permissions enforced.

$ tutti-ai add mcp
✓ installed @tuttiai/mcp · wrap any MCP server
How it works

Three files. One command. No hidden state.

01

Declare

Write a tutti.score.ts that names your agents, their voices, and their permissions.

$ tutti-ai init my-agent
02

Install voices

Pull voices from npm — or write your own as a typed Voice + Tool implementation.

$ tutti-ai add github slack
03

Run

One CLI command, streamed output, replayable traces. REPL, one-shot, or HTTP server.

$ tutti-ai run reviewer -p "review PR #42"
Recipes

Proven score files for real problems.

Browse all recipes →

A reviewer that reads the diff and the docs.

One agent fetches PRs from GitHub, reads the changed files from the working tree, and posts a structured review. Posting is destructive and gated by HITL when enabled.

import { defineScore, AnthropicProvider } from '@tuttiai/core'
import { GitHubVoice } from '@tuttiai/github'
import { FilesystemVoice } from '@tuttiai/filesystem'

export default defineScore({
  provider: new AnthropicProvider(),
  agents: {
    reviewer: {
      name: 'reviewer',
      model: 'claude-sonnet-4-6',
      system_prompt:
        'You review GitHub pull requests. Read the diff and the affected files, then post a structured review.',
      voices: [new GitHubVoice(), new FilesystemVoice()],
      permissions: ['network', 'filesystem'],
    },
  },
})
Voices

The plugin ecosystem is the framework.

16 official voices today — semver-versioned, with per-voice permission scopes the runtime enforces. Install like npm packages. Build your own as a typed Voice + Tool. Bridge any MCP server with one install.

Browse all voices →
Compared

Why teams pick Tutti.

Comparison against frameworks you're probably also evaluating, based on what each project's docs claim today. We'd rather hear corrections than ship a misleading checkbox — open an issue if anything looks wrong.

Feature Tutti LangGraph CrewAI AutoGen Mastra
Years in production at scale
Multi-language SDKs (Py + TS)
Visual debugger / Studio
Type-safe declarative config
Voice plugin ecosystem on npm
Per-voice permission scopes (runtime-enforced)
Destructive-tool HITL by default
MCP native
Model-agnostic by config
Auto model routing per turn
Hard cost budgets (run / day / month)
One-command deploy (Docker/Railway/Fly)
supported partial not supported

Every competitor builds agents. Tutti conducts them.

The design statement
Apache 2.0
licence
TypeScript
language
Node 24+
runtime
16
official voices
116
tools shipped
open
contributions welcome
FAQ

Things teams ask us.

How is Tutti different from LangGraph or CrewAI?

Tutti treats agents as declarative score files instead of Python graphs or role decorators. Everything — models, voices, guardrails — is typed and diff-reviewable. The voice marketplace is the extension model, not a pattern you reimplement per project.

Which models does Tutti support?

Claude, GPT, Gemini, Llama, Mistral, and any OpenAI-compatible endpoint. Swap providers by changing a single config line — your score file doesn't change.

Is Tutti production-ready?

Tutti is in early preview — public APIs may shift before 1.0. Core has extensive test coverage, every voice declares its permission scope, destructive tools are gated by default. v0.26 ships self-improving skills, scheduled delivery to Slack / email / Discord / Telegram / WhatsApp, and serverless deploy via Modal (with a verify-hibernate precheck) and Daytona. v0.25 shipped inbound messaging across five platforms; v0.24 shipped hard cost budgets, a deploy bundler, and a live cost-analysis CLI. We'd rather you try it on a real workload and tell us what breaks than wait for a 1.0 stamp.

How does pricing work?

Tutti is Apache 2.0 — free forever, self-hostable. There's no hosted product or paid tier today; you bring your own LLM provider keys and run it on your own infra.

What about security?

Every voice declares its permission scope. Secrets are redacted from logs by default, paths are sandboxed, and prompt-injection defences run on every tool response before the model sees it.

Start conducting.

One install. Your first agent running in 60 seconds. No signup. No telemetry.