Adjacent systems keep
- Harness finite and persistent agent runtimes
- Platform governed actions and audit trail
- Portable sandboxes, tools, and model providers
- Experiments evaluation and release evidence
Mission control · multi-agent squads
Command multi-agent squads.
Mission control for AI agent operations. Watch, steer, and approve named specialists through durable missions, policy-enforced tickets, and a shared runs ledger.
tower · the governed squad loophumans approve the edge
- 01
ASK
Operator question, cron, or webhook enters
- 02
PLAN
Lead agent decomposes a durable mission
- 03
EXECUTE
Named specialists run bounded tasks
- 04
TICKET GATE
Policy pauses external effects for a human
- 05
REPORT
Runs ledger records actor, model, tokens, outcome
- Durable units of work
- Missions
- Policy-enforced approval
- Tickets
- Agent evidence and cost
- Runs ledger
- Shared squad context
- Threads
Fabric family
PlatformHarnessExperimentsTemporal
One mission surface · many foundations
Tower coordinates squads on Databricks Apps, Temporal workers, and local Aspire stacks without rewriting the mission or ticket contracts.
DatabricksTemporalPostgresLakebaseAspireOPA
The 30 second answer
Tower owns squad operations. Agents stay portable.
People often hear Tower as another place to host models. That is the wrong layer. Harness runs agents. Platform governs mutations. Tower is mission control: orchestration, tickets, console, and evidence for multi-agent work.
Tower decides
- How multi-agent missions are planned and tracked
- How tickets pause external effects for human decision
- How squad roster, threads, and status stay correlated
- How runs ledger evidence is handed between operators
Harness builds the agents. Experiments judges them. Runway ships and governs delivery. Platform keeps everyone honest. Tower is where humans watch, steer, and approve all of it.
When mission control earns its keep
Three failures chat-only agent hosts do not solve.
Lead with operator outcomes, not another roster of model features. Tower differentiates after the first multi-agent crash, the long approval, or the missing evidence trail.
The chat dies mid mission
A multi-agent plan lives in a thread. When the process restarts, nobody knows which specialist finished, which tool double-ran, or who still owns the next step.
With Tower. Missions, tasks, and Temporal workflows keep squad work durable. Terminal state, tickets, and the runs ledger stay inspectable after interruption.
An agent acts without a human gate
External side effects land because a prompt said 'ask first'. There is no durable ticket, no exact operation binding, and no audit trail the next shift can trust.
With Tower. Anything leaving the trusted boundary pauses at a ticket enforced by policy, not by a system prompt. Approvals bind actor, action, and mission.
Evidence is scattered across tools
Cost, model choice, outcomes, and conversation history live in five dashboards. Operators cannot answer what the squad did or why a ticket was raised.
With Tower. The shared runs ledger records actor, model, tokens, outcome, and correlations. Missions, squad threads, and tickets stay tenant-scoped on one surface.
The product boundary
Squad orchestration and human control
are the product boundary.
Agent loops and tools exist in many frameworks. Tower starts where those hosts stop: multi-agent missions, durable tickets, operator console, and evidence you can hand off.
How it works
Ask. Execute under policy. Report with proof.
The same governed loop for operator asks, cron heartbeats, and webhooks, from local stub store to Databricks App and Temporal workers.
- 01
Ask and plan
Operator questions, schedules, and webhooks enter as typed Tower actions. The lead agent decomposes work into a durable mission with specialist tasks.
- 02
Execute under policy
Named agents run bounded tasks with explicit tools, roles, and limits. In-workspace work proceeds; external effects stop at tickets for human decision.
- 03
Report with evidence
Deliverables land with runs-ledger entries. Operators see who acted, what was approved, token use, and terminal outcome on one mission surface.
Choose the operating plane
Console for humans. Portable agents underneath.
Tower does not flatten every specialist into a single chat box. Operators get missions and tickets; agents keep Harness contracts, isolation, and runtime choice.
Operators · mission control
Watch the board. Approve the edge cases.
Missions, squad roster, tickets, and runs ledger give humans a single surface to steer multi-agent work without reading every tool trace.
- Mission board and detail
- One-tap ticket decisions
- Runs ledger and cost signals
Agents · portable specialists
Keep runtimes and policies where they belong
Specialists stay Harness agents with explicit tools, roles, and limits. Platform still governs mutations. Tower coordinates the squad and the human gates.
- Finite and persistent agents
- Policy and sandbox contracts
- Unity AI Gateway models when configured
The Tower difference
Squad orchestration and human control are the product boundary.
Agent loops, tools, and request-time confirmations now exist in several products. Tower differentiates where multi-agent work becomes long-running, approval-bound, or subject to operator handoff and evidence.
Mission control, not another agent runtime
Tower owns squad orchestration, the operator console, tickets, and the runs ledger. Harness keeps agents portable across runtimes and sandboxes.
Policy before side effects
Every state-changing path enters through the governed mutation boundary. Tickets enforce human decisions structurally, not by prompt hope.
Named specialists with shared context
Register agents, post squad messages, and keep threads correlated to missions so operators always know who is working and what is blocked.
Durable missions across interruption
Temporal-backed workflows keep ask → plan → execute → review → report alive through process loss, waits, and worker replacement.
Evidence operators can hand off
Runs ledger, tickets, and mission state stay tenant-scoped so the next shift can answer what happened without reconstructing chat history.
Complete control surface
Everything around the multi-agent loop, on one contract.
The differentiators are mission durability, policy tickets, and operator evidence. Tower also ships the console surfaces and governed actions needed to run a real squad.
Missions
Durable units of work with tasks, status, and a clear path from ask to report.
- Create and triage
- Task decomposition
- Status board
- Mission detail
- Tenant scope
Squad roster
Named specialists with live status, open work, and per-agent history.
- Agent registration
- Working / idle / blocked
- Per-agent runs
- Roles and tools
- Squad messaging
Tickets
One-tap approvals that bind the exact operation before external effects land.
- Policy-enforced pause
- Approve / reject
- Actor and action
- Mission correlation
- Slack notify
Runs ledger
Cross-agent evidence for models, tokens, outcomes, and correlations.
- Actor and model
- Token usage
- Terminal outcome
- Filterable history
- Genie analytics
Governed actions
Typed actions enter the same pipeline whether the caller is human, cron, or agent.
- tower.ask
- tower.create_mission
- tower.run_task
- tower.file_ticket
- tower.answer_ticket
Fabric foundations
Compose Platform governance, Harness specialists, Experiments evaluation, and Temporal durability.
- Platform mutations
- Harness agents
- Experiments gates
- Temporal workflows
- Databricks App
Workloads
Not just another multi-agent chat room
Use the same mission, ticket, and ledger contracts for operations, data work, long-running processes, and engineering squads.
The governed loop
Agents move quickly. Policy decides where they stop.
There is no side door: agent decisions, human approvals, cron triggers, and webhooks all enter through the same action pipeline. Missions and tickets keep the loop inspectable after interruption.
- In-workspace work can proceed autonomously under policy
- Effects leaving the boundary require tickets
- Runs ledger correlates actor, model, tokens, and outcome
- Console projects state; mutations still go through invoke
tower · governed mission loop
- 01
tower.askOperator question, cron, or webhook enters
- 02
tower.create_missionLead agent plans a durable mission
- 03
tower.run_taskSpecialists execute bounded tasks
- 04
tower.file_ticketExternal effects pause for approval
- 05
tower.answer_ticketHuman decides; work continues or stops
Deploy
Meet operators where the work already runs
Use Databricks when the console belongs beside governed data. Use Temporal when missions must outlive processes. Develop locally with the same contracts.
FAQ
Straight answers to the comparison questions
Use these when someone asks whether Tower is another agent host or a mission-control surface.
How is Tower different from Harness?
Harness builds and runs finite or persistent agents with portable policy, sandboxes, and runtimes. Tower is mission control for multi-agent squads: missions, tickets, the operator console, and the runs ledger. Agents stay portable in Harness; Tower owns orchestration and human control.
Does Tower replace Platform governance?
No. Platform owns the governed mutation boundary. Tower routes human and agent work through that same pipeline so tickets, missions, and ledger entries stay honest.
Do I need Temporal to try Tower?
No. Local and stub-store paths work without Temporal. Add the Temporal worker when missions must survive restarts, multi-day waits, and worker replacement.
Where do agents actually run?
Specialists run under Harness contracts against the runtime and model plane you configure (including Unity AI Gateway). Tower coordinates missions and approvals; it does not become the agent runtime.
What is a ticket versus a chat confirmation?
A ticket is a durable, policy-enforced pause bound to actor, action, and mission. Approvals and rejections are one-tap console decisions with audit correlation, not a prompt that asked the model to wait.
Is the console multi-tenant?
Missions, tickets, threads, and runs stay tenant-scoped. Operator views project that store; mutations still go through governed actions rather than direct writes from the UI.
Contact
Talk to the team behind Tower.
Questions about mission control for your agent squads, a deployment on Databricks Apps, or how Tower composes with Harness and Platform? Send a note and an engineer replies.
Mission control · Fabric family
Command the squad. Keep humans in the loop.
Start with the documentation, then compose Platform governance, Harness specialists, and Temporal durability under one operator surface.
Fabric Tower is built and supported by TechFabric.
Contact TechFabric