ONTO vs CrewAI: Multi-Agent Without the Black Box

CrewAI broke through by making multi-agent orchestration feel approachable. Pick a “crew” of agents with roles, give them tasks, watch them collaborate. For a class of demos and prototypes it’s been the right tool.

ONTO has multi-agent support too, but it sits inside a different design. Subagents are scoped delegations; the parent agent is responsible for them; cost rolls up; depth is bounded. The starting shape in ONTO is one agent doing more, not many agents doing each less.

This post compares them where they overlap.

What CrewAI optimizes for

• Multi-agent collaboration as the central pattern. Define personas (researcher, writer, critic), give them shared context, let them iterate.
• Approachability. The mental model is intuitive: agents are like co-workers.
• Workflow flexibility. Sequential, hierarchical, and consensus-style processes are built in.

For prototypes and creative workflows, CrewAI’s structure is genuinely useful. The “let three personas collaborate” pattern is hard to express elsewhere.

What ONTO optimizes for

• Single-agent depth. Most ONTO users build one agent and use the runtime’s primitives (typed memory, Plan Mode, policy gates) to handle complexity.
• Subagents as scoped delegations. A parent can spawn a child with a constrained consent set. The child is a worker, not a peer.
• Bounded delegation. A depth budget prevents agents from infinitely delegating to subagents.
• Cost rollup. A child subagent’s token usage adds to the parent’s cost meter row.

calendar = onto.subagent(
    name="calendar",
    tools=["mcp:gcal:list", "mcp:gcal:create"],
    consent_scopes=["calendar:read", "calendar:write"],
)

result = onto.run_sync(
    "What's on my calendar this week, and what should I prep for?",
    user_id="alice",
    consent_scopes=["calendar:read", "memory:write"],
)
# The parent agent calls the calendar subagent. The child's cost rolls up.

When CrewAI is the right shape

• Creative or research workflows. Multiple personas critiquing each other genuinely helps quality on open-ended tasks.
• Demos and prototypes. The “crew” abstraction is fun to show and easy to iterate on.
• You like the collaborative-personas mental model. It’s a coherent frame for thinking about agent design.

When ONTO is the right shape

• Production deployments with audit requirements. Multi-agent flows are hard to audit when every persona has its own state. ONTO’s typed memory + consent scopes give you a single, queryable state.
• Regulated industries. “Three agents discussed and decided” is not an audit story regulators accept. “Plan Mode produced these tasks; human approved these; the runtime executed under these scopes” is.
• Multi-tenant SaaS. Cost rollup per tenant matters. Multi-agent CrewAI workflows can amplify cost in opaque ways; ONTO’s cost meter splits it by parent vs subagent and by tenant.
• When you only need one agent. Most production agent deployments are single-agent. Multi-agent is sometimes the cool answer to a problem that didn’t need it.

The multi-agent counterargument

There’s a real case for multi-agent that ONTO doesn’t try to compete on hard. If your problem genuinely benefits from multiple personas critiquing each other — code review by a panel, scientific writing with a researcher / editor / critic — CrewAI’s structure is well-suited.

ONTO can do this with subagents, but the design point is “scoped worker,” not “peer collaborator.” If “peer collaborator” is the right model for your problem, CrewAI fits better.

The cost / latency trap

A practical caution about multi-agent in general (true for CrewAI, true for any framework that makes it easy): every agent in the loop is an LLM call. Five agents discussing means five LLM calls per turn instead of one. The token bill multiplies, latency multiplies, and the marginal quality lift is often small.

ONTO’s design implicitly discourages this — subagents are deliberate delegations with a depth budget, not casual collaborators. Whether that’s a feature or a limitation depends on what you’re building.

A simple decision flow

Multi-agent collaboration is the *point* of your product?  → CrewAI.
You need typed memory + audit + consent across agents?     → ONTO.
You're building a single-agent product that occasionally
  delegates to a specialized worker?                       → ONTO (with subagents).
You want demos that show multiple personas working?         → CrewAI.

A note on direction

Both projects are evolving. CrewAI is adding more production controls (memory, audit). ONTO is adding richer multi-agent ergonomics. Don’t pick based on today’s feature gap if it’s a feature both are working toward.

Pick based on the shape of your product. Multi-agent at the center → CrewAI. Single agent with depth → ONTO. The shape is harder to change than the features.

---

The features page covers ONTO’s subagent model and consent scopes. The comparison page has the full matrix.

Frequently asked questions

Does ONTO support multi-agent?

Yes — through subagents. A parent agent dispatches to a child with a scoped consent set, the child runs as an independent agent, and its cost rolls into the parent's. There's a depth budget to prevent infinite delegation.

Does CrewAI have typed memory?

Not in the ONTO sense. CrewAI has agent state and shared context but doesn't ship UPO-style typed memory with provenance and decay. You can plug in an external memory layer.

Which is simpler to start with?

CrewAI for an experiment with multiple agent personas. ONTO for a single-agent production deployment that needs robust memory. Multi-agent in ONTO is a clean extension — subagents are first-class — but the typical starting shape is one agent with rich primitives.