Frameworks Are Coordination Machines

A framework earns its keep when it makes a hidden decision explicit: who owns state, who calls tools, and what ends the loop. Those decisions exist whether or not the framework names them. The coordination machine is the part your team writes. It decides who talks, what state the run keeps, which tool the system calls, when the loop stops, and how a person takes control.

A Second Agent Must Remove a Bottleneck

The multi-agent pitch is a room of specialists. Planner, coder, critic, researcher, executor. Each has a role, they pass messages, and the work improves.

Sometimes it does. Sometimes you get a meeting with no manager. The value comes from structure. That structure has clear roles, bounded turns, explicit handoffs, shared state, and a test that decides when the result is good enough.

The loop note named five steps: observe, decide, act, examine, remember. A role earns its existence by owning one. The planner owns decide, the executor owns act, and the verifier owns examine. A system where all three do the same job has one agent and three labels.

Add a second agent only when it removes a named bottleneck: different tools, different context, different verification, or different ownership. An agent that shares all four only adds turns.

AutoGen Turns Conversation Into Control Flow

AutoGen made the multi-agent idea concrete by treating conversation as a runtime primitive. You give each agent a role, connect them in a group chat, hand them tools, and set a stop condition. Control flow becomes the question of who speaks next.

The gain is separation. One monolithic chain runs a single voice through a single context. A group chat runs specialized participants under rules, so the research context stays out of the coding prompt.

The cost lands on state. In a group chat, the shared state is the transcript. The ReAct note asked you to replay one run from logs and explain every transition, and a transcript does not survive that test. You can read what each agent said, and you cannot recover which fact the system relied on when it acted.

StateFlow Trades Flexibility for Inspectability

Free-form conversation is flexible and hard to control. StateFlow puts the run in a named state, and it allows only the transitions on the list. The run stops for a reason the system can print.

You give up the move where an agent improvises a new step mid-run. You get four answers instead: the current state, the legal transitions, the evidence that moved the task forward, and the reason the run stopped.

The state machine is less magical than a group chat, and in production that trade pays. A named state and a stated stop reason let a colleague read a failed run they never watched.

LlamaIndex Is the Catalog the Agents Read From

An agent reads from whatever it can reach. It needs data, and data needs structure before retrieval works, so without the catalog and the labels the assistants wander.

A useful RAG system is a pipeline: ingestion, parsing, indexing, retrieval, reranking, synthesis, citations, and evaluation. The language model is one stage in that list. Multimodal knowledge assistants run on the same stages, and parsing turns mixed documents into something an index can hold.

Citations are the stage that decides trust. The test is whether the system can name the source of each retrieved fact. A system that retrieves well and cites nothing gives you a confident answer you cannot check.

A Framework Is Worth Its Weight When It Names the Contract

Write the contract before you pick the tool. The contract names the owner of each step and the tools each role can call. It also names the context the roles share, the memory the run writes, and the condition that counts as done.

With the contract on paper, the choice of framework stops being taste. Match the mechanism to the part of the work that needs it.

• Conversation fits the work where roles must negotiate a plan.
• A state machine holds a workflow where correctness outranks flexibility.
• Retrieval belongs wherever an answer must rest on evidence.
• An evaluator turns a run into a score you can improve against.

Adding a framework layer does not make state clearer by itself. More agents mean more confusion when nobody owns the facts, the tools, the errors, and the final decision.

The Builder Test

Take a system you run now and draw its contract on one page.

• Name the owner of state, then check that a second engineer can find it without reading the transcript.
• List the tools each role can call, and mark the ones whose actions are expensive to undo.
• Name the evidence the run saves, and make sure each retrieved fact carries its source.
• Write the stop condition, and make it stronger than the model announcing that it is done.
• Name what sends the task to a human, and name the human.

A field you cannot fill is a decision the framework already made for you. Read the framework code until you find where that decision lives.

What Carries

A framework gives you places to define reliability: schemas, permissions, retries, evaluators, logs, and handoff rules. Filling them is your job.

The lazy choice picks whatever makes the first demo shortest. The bill arrives later, when hidden memory, implicit retries, and an unreadable trace make one production failure impossible to explain.

A contract inside one team is a design choice. A contract inside a company is a permission boundary.