Multi-Agent Orchestration Without LangGraph or CrewAI
Multi-agent orchestration means coordinating several AI agents on shared work: who does what, in what order, with what context. The mainstream way to get it is a Python framework, and LangGraph and CrewAI are the two everyone learns. There is another architecture that involves writing no framework code at all. This is what it is, and when each fits.
What the frameworks are
Both are free, MIT-licensed (a permissive open-source license) Python libraries, both hit 1.0 in late 2025, and both are genuinely capable. LangGraph describes itself as a low-level orchestration framework for stateful agents: you write code defining a graph of steps, mixing deterministic code with model calls, with typed state flowing through. CrewAI organizes agents into role-based Crews inside event-driven Flows. Both ship persistence: LangGraph has checkpointers (saved snapshots of agent state) and cross-thread stores (memory shared across separate conversations), CrewAI a unified memory system (one built-in store for everything its agents remember). Neither is a toy, and this article claims nothing of the sort. Paid platforms (LangSmith, CrewAI's enterprise offering) sit alongside, but the frameworks themselves cost nothing.
What you are actually signing up for
A software project. With a framework, your orchestration is a Python application: you write it, version it, debug it, and keep it working as the framework evolves. The agents are objects inside your process. Their persistence is real but lives in-framework, scoped to that application's state, in the shapes the framework defines. For a team of engineers embedding agents inside a product, that is exactly right, and it is what these tools are for.
The question nobody asks: what if you are one person who wants a staff of agents, not an engineering team maintaining an agent application?
The other architecture: processes, a board, and shared memory
Instead of agents as objects in one program, run each agent as an independent CLI agent (a coding agent like Claude Code or OpenCode running as its own process). Coordination moves out of code and into shared infrastructure:
- A task board. Work is rows with owners and statuses. The orchestrator (the agent that assigns work to the others) posts tasks; workers claim them, do them, and post results for review.
- Shared memory. A memory and retrieval store that every agent reads and writes, so knowledge is infrastructure, not a variable inside someone's process. Any agent on any machine can hit it.
- Plain files. Each agent's identity, instructions, and skills are files you can read and edit. There is no build step between you and your system's behavior.
This is not our invention. CLI-agent orchestration is documented practice in 2026, from built-in subagents to external orchestrators coordinating many agents. What we did is turn one working version of it into a curriculum.
When to pick which
| Category | Framework (LangGraph, CrewAI) | CLI agents + task board |
|---|---|---|
| You are building | An application that contains agents | A staff of agents that does your work |
| Coordination lives in | Code you write and maintain | A task board and shared memory store |
| State and memory | In-framework: checkpointers, stores, memory classes | External infrastructure any agent can reach |
| Skills needed | Python, plus the framework | Reading and editing plain files; your agent writes the code |
| Best when | Agents ship inside a product; complex conditional logic; engineering team | One operator; heterogeneous everyday work; system must outlive any one program |
Both columns are legitimate. If you are embedding agents in a customer-facing product, use a framework; that is their home ground. If you are building a personal factory that runs unattended and survives tool churn, the process-and-board architecture asks less of you and breaks less when the ecosystem moves.
Where to learn the second one
Level 2 teaches it as a build: the task board and worker pattern, the orchestrator, memory at scale on a retrieval stack, and production operations, running unattended on hardware you control. It assumes you have a working single assistant first, which is Level 1's job. Completely new to agents? The free primer is the on-ramp.
Start free with the primer, build your assistant in Level 1, then scale it into the factory in Level 2 ($129 one-time). The honest comparison, including what Dark Factory is not, is on the compare page.