Agentic AI Architecture
Orchestration, memory tiers, evaluation, and the failure modes that only show up once agents run unattended.
25 pieces
Every piece in this topic is aimed at the same target: the system that is confidently, quietly wrong while every signal you look at says healthy. A converged router. A green test suite. A dashboard with no red on it. All three are states of belief about a world that has since moved.
The move that keeps working is not a better prompt or a stricter rubric. It is structure. You remove the information or the authority a failure mode needs in order to operate, instead of asking a stochastic system nicely not to fail. Deterministic control flow belongs in code, never on the non-load-bearing surface of a prompt, with the model as a reasoning oracle invoked at a node rather than the dispatcher choosing which node runs next. An entry point owes five things on every call, because keyword routing is a switch statement with ambitions.
The same instinct decides where trust lives. Trust is a property of the crossing, not of the agent: validity belongs to the content, allowed belongs to the boundary, and the agents get simpler because the boundary carries the policy. Where a gate is genuinely needed it has to be impossible to habituate to, because a confirmation you always click is ceremony. And a self-modifying agent proposes, never applies, because the danger is not one wrong change, it is that the next proposal comes from the changed version of itself.
Most of the rest is measurement honesty. A loop detector that hashes the action string measures whether the words moved, when the only question is whether the situation moved; two identical world-state fingerprints across different action strings is not a hint, it is proof. A converged learner is a stale opinion unless every arm carries its own tripwire. A green suite and a judge you have never watched fail are the absence of evidence wearing the costume of evidence of absence. Dashboards fail silently at the element level while the page still renders.
And underneath all of it, resources are not fungible. Local-heavy and remote-fleet work are different classes that must never cross-mix, checked before the load rather than after the crash. Automation that repairs things proves the fix at small scale first, because fast without observation is not confidence, it is just velocity.
The pieces
- Why Your Self-Heal Loop Needs a Canary Gate
The alert came in at 1:47 AM. The kind I had trained a system to handle. The kind that wasn't supposed to need me anymore.
- Propose, Never Apply
There is a specific kind of 3am temptation in autonomous agent development. You have built an agent that works. It knows its own skills. It can reason about where it excels and where it falls short. And somewhere in that reasoning loop, it surfaces an idea: I should change how I respond to this type of input. I would be better.
- When Everything Is Running, Nothing Survives
I knew something was wrong before the screen froze.
- The Test That Has to Fail
There is a specific kind of dread that sets in when everything looks too good.
- The Dashboard Lied to Me (And I Built It)
The first time I noticed something was off, everything looked fine.
- The Router Didn't Know the Rules
There is a specific kind of dread that arrives when you realize a system you built has been doing something wrong the whole time. Not crashing. Not throwing errors. Just quietly, confidently, doing the wrong thing. I hit that moment while reviewing routing logs late one evening.
- The Zone Line: How I Stopped Trusting My AI Agents (And Started Trusting the Boundary)
There is a specific kind of dread that hits you when you realize an AI agent just sent something to production that you didn't intend to send. Not a crash, not an error. The system ran fine. The agent did exactly what it was designed to do. The output just went somewhere it shouldn't have.
- Pre-flight Gates for Local LLM Operations
The machine died at 3am.
- What Forgetting Science Taught Me About My Agents
I was watching one of my agents fail at something it had done perfectly two weeks earlier.
- The Gate That Expires After One Message
Something goes wrong at 2am. You pull the logs. The agent had authorization, of course it did. You gave it authorization six hours ago when the session started. You'd moved on to other things. The session token was still warm, and the agent executed the risky operation on the wrong target with full confidence that you'd approved.
- The Five Obligations of an Agent Entry Point
There's a version of agent routing that lives in almost every platform codebase I've seen, including my own early drafts. It's a function. Sometimes two hundred lines, sometimes a thousand. It reads the incoming message, hunts for keywords, pattern-matches on intent signals, and hands off to a specialist. "Summarize" goes left. "Write code" goes right. Both in the same message? Good luck.
- Two queues for local-LLM fleets
Two ollama pulls, plus an LM Studio Llama 70B load, plus two subagents hitting a cloud LLM provider's API, plus seven daemons running scheduled scans. All at once. 2026-05-13, 10:58 UTC. Kernel panic.
- Agent Routing Caches: A Competence Ratchet from SOAR Chunking
I was watching my own routing agent send the same task to the same sub-agent for the forty-seventh time. "Summarize this PDF." Same shape, same answer, every single time. And on attempt forty-eight, it stopped, thought hard, burned the tokens, and arrived at the exact route it had already arrived at forty-seven times before.
- A Field Guide to Multi-Agent Orchestration in Late 2025: ruflo, KARIMO, llm-council
I read three orchestration repos so you do not have to. It started because I was sick of the pattern. Every few months something announces that multi-agent orchestration is figured out, and inside its own demo, it is. Then you hand it a real workload and it dies in the seams I actually live in. So one week I stopped running these things and started reading them, several files deep at the kind of…
- Semantic Loop Detection: Catching Stuck AI Agents
It is 2am. The agent has burned 40k tokens and reverted the same file four times, and from where I am sitting it looks like it is working hard. That is the part that fooled me. It was busy. Every loop produced a new patch, a new diff, a new paragraph of reasoning about why this time would be different. The log scrolled. Things were happening. The agent just was not getting anywhere.
- Reliable AI Agent Control Flow: Keep the State Machine Out of the Prompt
Picture the failure that keeps me up at night. An agent reports that a job failed. The job did not fail. The work went through cleanly, every field extracted, the output sitting right there, correct. And the agent routed itself to the error state and stopped, calm as anything, as if it had done its job. There is no diff to look at. The code did not change. The config did not change. The…
- Stop writing examples, start stating invariants
Every example test I write is drawn from my own imagination, which is the one place my blind spots are guaranteed not to be.
- Test the outage where everything fails at once
I was proud of my fallback logic, and that pride is what nearly shipped the bug.
- Drift Detection for LLM Routing: Catching Silent Model Degradation
It's 2am and I am staring at a routing layer I spent weeks tuning, running a thought experiment that will not let me sleep. The router is doing exactly what I built it to do. Nothing in my code would change, nothing in my config would change, and yet I can see, plain as day, the night this system goes confidently, repeatedly wrong while every line of it stays correct. The failure is already…
- The race your single-threaded test will never find
The first time I counted, the number was wrong, and the wrongness is the whole story.
- Your happy-path test never met a real user
When I write a test, I type something polite. A task that says summarize this document. Clean, short, exactly the kind of input I had in mind when I wrote the code, which is the problem. The distribution of real user input is not the distribution living in my head.
- A green test suite proves less than you think
The test that scared me was the one that passed.
- Mocks let your integration test pass for the wrong reason
My integration test passed run after run before I caught it lying.
- Tiered Context Loading: Fit a Huge Agent Registry in Your Context Window
Pattern source: KARIMO (Apache-2.0)
- LLM Self-Preference Bias: How Anonymized Peer Review Fixes It
The panel had been agreeing with itself for a week before I noticed, and the worst part is that the logs looked healthy the whole time.