Agents as a team
Give each agent a role, then run them together as one workflow instead of a pile of separate prompts.
BUILD AI TEAMS IN SECONDS
Buildmulti-agentic workflowsin seconds
The best way to build multi-agentic systems that handle real tasks, use your tools, and show every step as they work.
Free to use.
getassemble.dev/app/runs
supervisor
support-router
routes each step to the right agent
done
classifier
labels the ticket
running
refund-specialist
resolves the refund
approved
issueRefund()
typed tool call
policy: human approval recorded
workflow.completedtraced · replayable
OPENAI
ANTHROPIC
META
MICROSOFT
RUNWAY ML
N8N
HUGGING FACE
MISTRAL
COHERE
PERPLEXITY
VERCEL
SUPABASE
STRIPE
GITHUB
REPLIT
CURSOR
LINEAR
NOTION
FIGMA
DATABRICKS
CLICKHOUSE
Stop wiring agents by hand.
The old way
- Write custom glue code for every agent
- Manually pass data between steps
- Patch together tools, memory, and approvals
- Rebuild the same workflow logic again and again
The Assemble way
- Define each agent and what it should do
- Connect tools once and reuse them anywhere
- Add approvals, routing, and memory without extra plumbing
- Run the whole team as one working system
Code-first
Your entire workflow lives in one file.
- Define the agents, tools, routing, and outputs together.
- No hidden builders.
- No scattered config.
- No mystery orchestration.
support-workflow.ts
import { agent, workflow } from "@assemble-dev/sdk";
import { anthropic } from "@assemble-dev/providers";
import { z } from "zod";
const classifier = agent({
name: "classifier",
model: anthropic({ model: "claude-sonnet-4-5" }),
outputSchema: z.object({ category: z.enum(["refund", "technical"]) }),
});
const specialist = agent({
name: "refund-specialist",
model: anthropic({ model: "claude-sonnet-4-5" }),
outputSchema: z.object({ reply: z.string() }),
});
const support = workflow({ name: "support", agents: [classifier, specialist] });
const result = await support.run({ ticket: "Refund order ord_1" });Everything, connected
Everything agents need to work together
Tools wired once
Connect your APIs, databases, and internal tools once. Let any approved agent use them safely when the work needs it.
Rules before actions
Decide what agents can do, what needs approval, and what should be blocked before a tool ever runs.
Every step visible
See which agent ran, what it decided, which tool it used, and why the workflow moved forward.
Replay any run
Rerun the same workflow from a saved trace and compare what changed when prompts, tools, or models are updated.
Bring your own models
Use your own OpenAI, Anthropic, or Gemini keys. Assemble coordinates the workflow, but your app talks to the models directly.
Build the team. Run the work. See every step.
Assemble turns separate agents into one working system you can understand, control, and improve.
1
Build
Create agents with clear roles and connect the tools they need to do real work.
2
Run
Send in a task and let the agents route, act, and hand off work together.
3
Observe
Follow the full run from start to finish, including decisions, tools, approvals, and final output.
Built for the way you build
SOLO BUILDER
BUILD WITHOUT A MESS
Create agents, connect tools, and run complete workflows without writing the same glue code over and over.
PRODUCT TEAM
BUILD WITH OBSERVATION
Give your team one place to see what ran, what changed, what failed, and what needs approval
AI ENGINEER
BUILD WITH CONTROL
Set roles, rules, tools, and handoffs upfront so your agents behave like a system, not a pile of prompts.
Developers see the difference
I stopped writing custom glue code and had a working agent team running the same day. The trace made every handoff easy to understand.
I can define the team, connect tools, and see every step without building the same orchestration layer from scratch.
Agents finally feel like one system instead of a pile of prompts. The visibility alone saves hours of guessing.