The AI FOMO Trap: Why your Multi-Agent System is brittle (and how to fix it)

Glendel Joubert Fyne Acosta — Thu, 14 May 2026 00:45:30 +0000

A developer on Reddit recently told me: "Companies right now are risking the LLM-led parts of their architecture due to FOMO. We'll see how far they get".

He is absolutely right. Fear Of Missing Out is driving engineering teams to ship "Autonomous Agents" at breakneck speed. But in the rush to production, we are abandoning 20 years of established software engineering principles.

We are letting probabilistic models control deterministic runtimes.

If you are routing network traffic, validating data schemas, or checking user permissions using an LLM prompt, you are not building a resilient system. You are building a fragile prompt-chain wrapped in hope. When it fails (and it will), it will be slow, expensive, and completely un-auditable. InfoSec won't accept "the model hallucinated the auth check" as a valid incident report.

The Cure: The Manager-Executor Pattern

To build enterprise-grade Multi-Agent Systems, we must separate the Cognitive from the Deterministic.

1. The Manager (Probabilistic) This is the LLM. Its only job is to reason, plan, and analyze context. It decides what needs to be done. It does not execute code. It does not manage its own memory. It requests actions via strict JSON schemas.
2. The Executor (Deterministic) This is your runtime framework. It acts as the boundary. When the Manager requests an action, the Executor:

Verifies the agent's permissions.
Validates the payload against a strict schema.
Checks the token/cost budget.
Executes the code (API call, DB write).
Returns the exact result to the Manager.

The Framework Controls the AI

The fundamental shift required in MAS architecture is understanding that the framework must control the LLM; the LLM must never control the framework.

Right now, developers are having to build these custom state machines and validation layers from scratch because popular frameworks default to LLM-routing. It's time we standardize this. We need "A Real Framework" for Multi-Agent Systems—a framework that enforces the Manager-Executor pattern by default.

Stop relying on vibes-based engineering. Let's get back to rigorous software architecture.

The Token Waste Problem: Why your AI Agents shouldn't evaluate permissions

Glendel Joubert Fyne Acosta — Sat, 09 May 2026 00:47:02 +0000

We are burning millions of API tokens on problems that if statements solved 20 years ago.

I speak with developers building Multi-Agent Systems (MAS) every day, and I keep seeing the same massive architectural anti-pattern: Routing everything through the AI model.

Need to check an agent's permissions? "Ask the LLM."
Need to route a message? "Ask the LLM."
Need to validate a data schema? "Ask the LLM."

Language models are extraordinary reasoning engines. But they are also expensive, probabilistic, and relatively slow. If a problem has a deterministic, correct answer (like checking an access policy), it should be evaluated by runtime code, not guessed by a neural network.

The Anti-Pattern

Instead of doing this (Probabilistic):

// BAD: Asking the LLM to check permissions
const prompt = `You are an agent. The user wants to delete a file. 
Here are their permissions: ${user.permissions}. 
Should you allow it?`;

const decision = await llm.generate(prompt);

The Solution

We need to get back to doing this (Deterministic):

// GOOD: Let code handle policy, let AI handle reasoning
if (!user.hasPermission('delete_file')) {
  throw new Error("Unauthorized"); 
}

// Only call the LLM for actual cognitive tasks
const plan = await agent.reasonAboutFile(file);

AI should decide what to do. Deterministic code should execute it and enforce the boundaries.