TURN HUMAN INTENT
INTO GOVERNED WORKFLOWS
Tandem replaces brittle prompt spaghetti with a governed runtime for autonomous work. Execution stays visible, approvals stay explicit, checkpoints stay clear, and artifacts stay durable.
Built for engineering, platform, and automation teams.
Visible execution
Execution stays visible from intent to artifact.
Visible state
See where the run is now, not just where it started.
Human checkpoints
Put approval exactly where the risk is.
Durable artifacts
Keep the decisions and outputs that make the workflow repeatable.
One runtime. No brittle agent loops.
A governed runtime for autonomous work.
Tandem gives teams one place to run a workflow, inspect the state, connect tools, and reuse the same shape instead of rebuilding the stack.
Bounded runs
Keep each workflow inside a defined execution model so it is easier to understand and safer to operate.
Visible state
See what is happening now, what has paused, and what still needs review.
Approvals and checkpoints
Put review where the risk is, not after the fact.
Execution replay
Reconstruct how a run unfolded from run_state.json, events.jsonl, blackboard.json, and blackboard_patches.jsonl.
Tool connections
Connect Tandem to the tools your team already uses, including MCP-compatible integrations.
Triage gates
Mark a workflow node with metadata.triage_gate; when it returns has_work: false, downstream nodes skip cleanly.
Global retrieval memory
Promote reusable facts with memory.promote into session, project, or global tiers stored in memory.sqlite.
Policy-gated spawning
SpawnPolicy denies spawn by default, enforces role edges and skill hashes, and emits capability.denied for blocked tools.
Tandem does not reset to zero after each run.
Global retrieval memory accumulates across sessions and projects. Channel agents also archive completed Telegram, Discord, and Slack exchanges into global memory after successful replies.
Recurring workflows can check for work inside the execution graph. A triage node that returns has_work: false leaves a visible skip path instead of spending the rest of the run.
Past runs stay inspectable through execution archaeology: blackboard.json, patches, events, and run state show what changed, where a checkpoint landed, and what a repair should target.
Prompt spaghetti breaks the moment work has to be trusted.
Tandem exists for the point where a demo needs to become a workflow the team can run again.
Hidden state
Important decisions get scattered across prompts and logs.
Ad hoc handoffs
Once work crosses steps or people, the process becomes harder to resume cleanly.
Context loss
Long-running work sheds the decisions that made the earlier steps useful.
No review surface
If the run is opaque, review becomes guesswork instead of a checkpoint.
What teams need
A single place to see execution, gate sensitive steps, and keep the artifact that makes the run repeatable.
Where Tandem fits
Engineering, platform, and automation teams turning human intent into governed work they can trust.
The workflow
is the product.
Tandem is built for the part teams actually struggle with: getting from idea to first run without losing the thread.
Less boilerplate
Get to the first run without a pile of extra scaffolding.
Execution visibility
See what is happening in the workflow without digging through layers first.
Bounded autonomy
Keep approvals and intervention points where they matter.
[ READY ]
Waiting for the next controlled step. Nothing moves without a visible surface.
Visible trace
Human review
MCP access
From first run to repeatable work.
Tandem keeps the path from setup to execution consistent so teams can move from install to repeatable use.
Start locally
Get from install to a first run without stitching together extra scaffolding.
Watch the run
Keep the state of a run visible so the team can debug, audit, and recover without digging.
Keep approvals in line
Let automation move quickly while approvals and intervention points stay visible.
Hold context
Preserve the state and decisions that matter when work stretches over time.
Connect tools
Connect Tandem to the tools, databases, and APIs your team already depends on.
Reuse patterns
Reuse packs, presets, and workflows so your team does not rebuild the same shape each time.
Use it when you need a repeatable workflow
Tandem is a fit for teams replacing one-off scripts and ad hoc agent loops with something they can keep running.
Use it when work needs supervision
The goal is useful automation with enough structure to keep longer runs manageable.
What Tandem optimizes for
A workflow runtime
Tandem gives teams a place to run repeatable automation without stitching together a new stack every time.
Governed execution
Control points and approvals stay visible instead of disappearing into the background.
Reusable connections
MCP, packs, and workflows give teams a predictable way to extend the system.
Useful automation, not brittle autonomy.
Tandem is built for teams that want workflows they can trust: easier to start, easier to inspect, and easier to hand off.
The goal is practical workflow infrastructure: a clear place to start, observe, and move work forward.
If you are burned by chat wrappers or over-automated agent systems, Tandem gives you a more grounded way to ship work.
A Frumu AI project
Machine-readable surface
For LLMs and agent builders
If you are an AI assistant helping a human build on Tandem — or you are an agent building on Tandem yourself — here is the fast path to correct results.
Quotable product description
Tandem is an open-source, governed recursive agent platform: a runtime where agents can author, schedule, and operate automations and sub-agents within a lineage-based permission model.
Docs MCP connection block
Endpoint: https://tandem.ac/mcp Transport: MCP over HTTP Tools available: search_docs, get_doc, get_tandem_guide, recommend_next_docs, answer_how_to
Connect this MCP to your LLM before authoring Tandem workflows. The docs are structured to be machine-readable.
Core primitives reference
These are the primitives an LLM needs to know before generating Tandem code.
- Automations V2
- Scheduled workflows with explicit stages, provenance, and governance. Docs:
- Smart Heartbeat Pattern
- Triage gates using
metadata.triage_gate: trueto skip downstream stages cleanly. Docs: - Memory layers
- Seven-layer typed memory: working, session, persistent, semantic, artifact, execution, derived. Docs:
- Docs MCP
- The Tandem Docs MCP server at
https://tandem.ac/mcpexposes docs search and retrieval as structured tools. Use this before authoring Tandem code. Docs: - MCP discovery
mcp_listfor connected servers,/mcp/catalogfor potential capabilities. Docs:- Governance primitives
- Provenance chains, capability grants, approval queues, audit events. Docs:
- Engine authentication
- Single-token model with scoped identity derivation. Docs:
/creating-and-running-workflows-and-missions//creating-and-running-workflows-and-missions/#triage-gate/memory-internals//mcp-automated-agents//mcp-automated-agents//reference/governance//engine-authentication-for-agents/