Hub / Guides / Frameworks vs ops

Multi-agent orchestration

Frameworks build agents; ops runs them

Yes. You can choose a framework with confidence once you judge it on how it will be run, not only how it's built, and we bring that ops checklist to the decision. CrewAI, LangGraph, AutoGen, and the OpenAI Agents SDK are build tools; cost, audit, identity, and evaluation are ops questions.

Why does "CrewAI vs LangGraph" miss the production question?

Comparison searches usually weigh developer experience: how agents are defined, how state flows. Those matter for building. In production the questions change: who approved this run, what did it cost, which credentials did it use, and did quality hold this week? Our research found buyers rarely get those criteria alongside framework comparisons (research gap, not a vendor claim).

Is OpenAI Swarm production ready?

OpenAI's Swarm repository describes itself as educational and experimental, and points to the Agents SDK as its successor. If you started on Swarm, plan a move to the Agents SDK — and use the move to add the ops layer below.

What should an ops checklist cover?

Score any framework, or mix of them, on these. No winner here — your answers decide.

Cost

Audit

Identity

Evaluation

Traces

Where do frameworks end and the platform begin?

Snowflake's split helps: frameworks handle orchestration. Observability tools record runs. The control plane holds policy, identity, and audit. Enterprise "multi-agent orchestration platform" pages from IBM, BMC, and Runflow bundle more of these layers; read their pages to see which.

What goes wrong when the framework is treated as the platform?

How do I decide in practice?

  1. Pick the framework your team builds fastest in.
  2. Run the checklist above against your whole stack.
  3. Fill each empty box with a tool or a rule, owned by a person.
  4. Re-run the checklist before each new agent.

What does running the checklist look like?

Say a team builds a research agent on one framework and a writing agent on another. The eng lead fills in the checklist with the reviewer and the owner in one short session.

Cost. The eng lead finds both agents bill to one key. The answer to "spend per agent" is no. Fix: split credentials and tag each call with agent and task.

Audit. Each framework writes its own logs in its own format. The reviewer can see what one agent did but has to dig through another tool for the second. Fix: send both to one record of runs and approvals.

Identity. The writing agent can read a folder it never needs. The owner decides it shouldn't, and the eng lead narrows access.

Evaluation. Both agents passed a demo a month ago; neither has been checked since. The reviewer sets a weekly check with a small set of known tasks.

Traces. One framework exports traces in an open format; the other needs an adapter. That goes on the list as a task with a name, not a reason to switch frameworks.

At the end, every unchecked box has an owner and a date. The framework choice didn't change; the ops layer around it did.

When does switching frameworks make sense?

Switch when the build is the real problem: the team can't express the workflow, or the project is marked experimental by its own maintainers, as Swarm is. Don't switch to fix cost, audit, or identity gaps — those follow you to the next framework unless the ops layer above it covers them.

How do you request a consult?

We run this checklist on your stack.

Request a consult

What else do operators ask?

Which framework should we pick?

We don't rank them. Choose for your team; govern with the checklist.

Can I mix frameworks?

Yes, if identity, audit, and spend sit above them.

Should I move off Swarm?

Its own repo calls it experimental and names the Agents SDK as successor.

Do I need a separate observability tool?

Only if your stack doesn't already give every framework one trace view.