Somewhere around the third production incident caused by a language model confidently inventing a discount policy, we started writing rules again. Actual rules. If-then, constraint-solver, "this transaction cannot post unless the ledger balances" rules. It felt like archaeology. It turned out to be the most important architectural decision in the venture.
What LLMs are bad at is exactly what GOFAI is good at
Large language models are extraordinary at the fuzzy half of work: reading messy input, inferring intent, drafting, summarizing, negotiating ambiguity. They are structurally bad at the crisp half: arithmetic that must be exact, policies that must be enforced every single time, and state that must stay consistent across a long process.
Symbolic systems — rules engines, constraint solvers, planners, plain state machines — are the mirror image. They can't read an email to save their lives, but they never approve a refund above the limit, never let an order skip a compliance step, and never get creative with a tax table.
The LLM proposes. The symbolic layer disposes.
That's the pattern, and it's older than it looks: perception and judgment in one system, verification and execution in another. The model reads the invoice and extracts a structured claim; the rules engine decides whether that claim is allowed to touch money.
Three pairings that keep showing up
- LLM in front, rules behind. The model turns unstructured input into structured proposals; a deterministic layer validates every field against hard constraints before anything executes. This is our default for any agent that touches funds, inventory, or a customer promise.
- Rules in front, LLM behind. A symbolic router handles the 80% of cases with clear rules at near-zero cost, escalating only genuine edge cases to the model. Inference spend drops an order of magnitude, and the easy cases become perfectly predictable.
- LLM as author, rules as artifact. The model helps a domain expert write and maintain the rulebook — but the artifact deployed is the rulebook, not the model. You get symbolic reliability with LLM-era authoring speed.
Why this matters economically
The hybrid isn't just an engineering aesthetic — it changes the business case. Deterministic layers are cheap to run, cheap to test, and auditable, which converts "the agent is usually right" into "the agent is provably right within these boundaries." That sentence is the difference between a demo and something an insurer, a bank, or a regulator lets you deploy. It also shrinks the human-review overhead that quietly kills most agent ROI.
The field spent two decades treating symbolic AI as the embarrassing ancestor. In practice it's the missing half. The businesses we're building don't choose between the two — they blend them, the way you'd blend any capabilities: by putting each where its economics are strongest.