The Graph Was The Problem — And Netic Proved It

Every agent framework built in the last two years has the same assumption baked in: complex tasks need complex graphs. LangGraph, CrewAI, AutoGen, Dify — they all encode workflows as nodes and edges, with classifiers at every junction and specialists for every subtask.

Netic just published the most honest post-mortem of this approach I've read. They ran a 223-node, 646-edge voice agent graph in production for two years, servicing real customers booking HVAC, electrical, and plumbing jobs. Then they ripped it out and replaced it with a single open-source LLM — no graph, no orchestrator, no classifiers.

Containment and booking rates went up 15 points. Time to first token dropped from over a second to ~500ms. Customer onboarding went from days to one hour.

This isn't a lab experiment. It's a production debrief from a team that was making it work — and still concluded the architecture was wrong.

---

How Graphs Fail at Conversation

Netic identifies four failure modes, and each one maps directly to experiences I've had running agent systems. They're worth examining because they're not specific to voice — they apply to any agent graph.

1. The Graph Commits Before It Has Information

A graph forces a routing decision at the first turn — when you have the least information. Real callers reveal their intent gradually, out of order, and often after the system has acted on a guess.

Netic's example is brutal:

• Customer: "It's got no electric."
• Graph routes to ELECTRICAL branch.
• Customer: "No. It's the boiler."
• Agent verbally accepts the correction. System state never changes.
• Job booked as electrical service. Customer has no heat.

The fix? Add an edge routing backwards. But that edge meant weeks of tuning before it fired reliably. The graph assumes forward progress. Correcting mid-call meant fighting the architecture.

I've seen this exact pattern in code agents that commit to a file path early and can't uncommit — they dig deeper into the wrong function because the graph already routed them to "analysis mode" before the user finished describing the problem.

2. Context Starvation Is Baked Into the Design

Each node in a graph sees only the context its author wired in. That's intentional — it keeps the prompt predictable. But it means the answer to a question lives in a different node than the one running the conversation.

Netic's example: a caller asks "how much is the emergency visit?" The node offering emergency service doesn't have pricing in context. Pricing is gated behind accepting the offer first. The agent repeats its script six times until the customer hangs up.

Though the price existed in our system, the node offering the service didn't have it in context. It couldn't reach the node that did without the customer first accepting the offer.

This isn't an edge case — it's a structural property of graphs. Every time you split context across nodes, you create opportunities for the left hand not to know what the right hand is doing. The workaround is to build classifier nodes, then tool-call routers, then context bridges — and each one is another failure surface.

3. The Maintenance Spiral

Netic started with simple if-else conditions. Those became if-elif-elif chains. Then classifier nodes. Then the classifiers themselves needed tuning per customer. By the end: 223 nodes and 646 edges.

The gradient here is instructive: taken to its limit, a fully connected graph with every node able to route to every other node is just a single agent with extra steps and worse latency. The graph becomes a distributed, fragile implementation of what a single model with full context could do natively.

Every new customer required rewiring shared components. An override written for one customer silently missed refinements the shared components picked up later. Standing up a new customer meant learning a vocabulary of primitives — the graph itself was an onboarding bottleneck.

4. Specialists Cannot Diagnose Their Own Failures

Netic's multi-agent experiment produced the scariest finding: a specialist cannot recognize it's stuck. In one session, a customer texted to cancel service because they sold their house. The cancellation specialist called the wrong tool 25 times despite receiving the complete job history. The run ended when the framework's recursion limit killed it. The customer's last message: "I don't have time for this, bye."

Futility is only visible from outside a specialist's context. Orchestrators and their subagents drift out of sync because each holds its own partial picture, and every handoff is a chance for those pictures to diverge further.

---

The Pivot: One Agent, Full Context

What Netic runs today is almost absurdly simple compared to what came before:

graph TD
    A[Customer Call] --> B[Single LLM Agent]
    B --> C{Has full conversation history}
    B --> D{Loads relevant procedures on demand}
    B --> E{Gates only irreversible actions}
    C --> F[Streams response]
    D --> F
    E --> F
    F --> G[<500ms TTFT
+15pts containment]
    style G fill:#1a3a1a,stroke:#22c55e
    style B fill:#1a1a3a,stroke:#818cf8

Four principles guide it:

1. Constrain outcomes, not paths. Determinism lives at the tool boundary — the points of irreversible action. The conversation itself has no prescribed shape.
2. The model sees everything. Full conversation history and relevant procedures in context. Most graph-era failures were context starvation in disguise.
3. Instructions over primitives. Policy is stated once as natural language procedure text. Current models follow it reliably enough that structural enforcement is redundant.
4. One agent per conversation. Context never fragments across specialists. There is no handoff to go wrong.

The models that made this possible — Kimi K2.6 and GLM 5.2 — are open-weight. Running your own inference is what enables sub-500ms TTFT. Netic isn't using a closed API; they control the stack end-to-end.

What This Means for the Rest of Us

The graph era isn't over. Graphs are correct for many things: CI/CD pipelines, data processing, ETL, state machines. But conversation — and by extension, agentic interaction — doesn't fit the mold.

The trend I'm watching is this: as models get better at instruction following, the scaffolding around them gets simpler, not more complex. The teams getting the best results in production right now are removing abstractions, not adding them. Netic joins a growing list — including companies like Cognition (Devin) and Factory — who've discovered that a single model with well-structured context beats a committee of specialists with tightly scoped prompts.

The graph was a crutch for when models couldn't follow instructions reliably. In 2025, closed models crossed the threshold. In 2026, open-weight models have caught up. The scaffolding we built to compensate for model weakness is now the thing holding our systems back.

The bottom line: If your agent system has more than 10 nodes, ask yourself whether you're solving for model capability or papering over its absence. The answer might save you 646 edges of pain.