On October 19, 2026, Meta's engineering team published a post on its official engineering blog reviewing how it rebuilt its data pipeline agents: the control layer became a thin orchestrator of roughly 1,300 lines of code that only routes work and enforces reliability checks, performing zero domain reasoning itself, while dispatching more than 20 workflows to 14 specialized subagents with isolated contexts. After the rebuild, configuration prep for a new data column dropped from three to four days by hand, and about a day with the earlier system, to under an hour.
Why the all-knowing agent failed first
Meta started the way most teams do: one agent loaded with all domain knowledge, with configuration schemas, code generation rules, validation requirements and population patterns for more than 10 data sources in a single context. It worked in demos and started hallucinating in production: past a certain context threshold, additional knowledge degraded performance, and naming conventions and generation patterns from different subsystems contaminated each other. The team measured a 70 to 80 percent success rate for the single-agent approach when engineers hand-crafted a custom prompt for each task, dropping to 10 to 20 percent without that handholding. A preprint they cite found the same pattern: orchestrated multi-agent systems held 65.3 percent accuracy on 80-task batches where single agents fell to 16.6 percent, while using up to 65 times fewer tokens.
Only one of seven steps uses the large model
The thin orchestrator runs a fixed seven-step protocol for every request: read the relevant subagent's instruction file, check whether the target already exists, gather required fields from the user, auto-discover what can be inferred, pass a reliability gate, delegate to the subagent with full context, and handle results and errors. Steps one to five and step seven are deterministic; only step six involves large-model reasoning, and it happens inside an isolated subagent loaded with only its own domain knowledge. Every subagent shares the same structure: knowledge sources, a pre-gathering checklist, execution steps, code discovery patterns and troubleshooting mappings. More than 25 knowledge files are loaded on demand, so an update takes effect in the next session with no orchestrator changes. When a subagent fails, the orchestrator retries or escalates, and the failure cannot corrupt other subagents' contexts.
New scenarios come from templates, not new agents
Column onboarding, event onboarding and pipeline migration all reuse the same pool of 14 subagents in different sequences. Pipeline migration was a completely new use case, yet the team wrote no new agent code for it: a new workflow template sequencing existing agents differently delivered full production capability. About two-thirds of the system's changes now land without significant human edits. Meta's advice to other teams is blunt: routing is a deterministic decision, so do not hand it to a large model; push all domain reasoning into isolated specialists. It points the same way as this site's earlier coverage of Anthropic consulting lawyers on agent rules: production agents succeed not because a single model got smarter, but because boundaries and rules were fixed first.
