{"slug": "dispatches-from-o-reilly-fast-paths-and-slow-paths", "title": "Dispatches from O'Reilly: Fast paths and slow paths", "summary": "This article from O'Reilly Radar examines the challenge of governing autonomous AI systems, arguing that requiring synchronous approval for every decision creates brittle, slow architectures. Instead, it advocates for distinguishing between \"fast paths\" (preauthorized, routine operations) and \"slow paths\" (decisions requiring oversight), treating governance as a feedback mechanism rather than a universal approval gate. The piece concludes that effective control must be applied selectively to preserve the autonomy and utility of production AI systems.", "body_md": "[Ed. note: We’re opening up a Friday column slot on the blog to provide regular insight from voice within the developer community, either here at Stack Overflow of outside of it. This is the first of those columns, a republication of one of the articles on O’Reilly Media’s blog, Radar. We’ll have a repost from them every month.]\nThis post was originally published on O’Reilly Radar and is being republished here with the author’s permission.\n—————————-\nAutonomous AI systems force architects into an uncomfortable question that cannot be avoided much longer: Does every decision need to be governed synchronously to be safe?\nAt first glance, the answer appears obvious. If AI systems reason, retrieve information, and act autonomously, then surely every step should pass through a control plane to ensure correctness, compliance, and safety. Anything less feels irresponsible. But that intuition leads directly to architectures that collapse under their own weight.\nAs AI systems scale beyond isolated pilots into continuously operating multi-agent environments, universal mediation becomes not just expensive but structurally incompatible with autonomy itself. The challenge is not choosing between control and freedom. It is learning how to apply control selectively, without destroying the very properties that make autonomous systems useful.\nThis article examines how that balance is actually achieved in production systems—not by governing every step but by distinguishing fast paths from slow paths and by treating governance as a feedback problem rather than an approval workflow.\nThe question we can’t avoid anymore\nThe first generation of enterprise AI systems was largely advisory. Models produced recommendations, summaries, or classifications that humans reviewed before acting. In that context, governance could remain slow, manual, and episodic.\nThat assumption no longer holds. Modern agentic systems decompose tasks, invoke tools, retrieve data, and coordinate actions continuously. Decisions are no longer discrete events; they are part of an ongoing execution loop. When governance is framed as something that must approve every step, architectures quickly drift toward brittle designs where autonomy exists in theory but is throttled in practice.\nThe critical mistake is treating governance as a synchronous gate rather than a regulatory mechanism. Once every reasoning step must be approved, the system either becomes unusably slow or teams quietly bypass controls to keep things running. Neither outcome produces safety.\nThe real question is not whether systems should be governed but which decisions actually require synchronous control—and which do not.\nWhy universal mediation fails in practice\nRouting every decision through a control plane seems safer until engineers attempt to build it.\nThe costs surface immediately:\n- Latency compounds across multistep reasoning loops\n- Control systems become single points of failure\n- False positives block benign behavior\n- Coordination overhead grows superlinearly with scale\nThis is not a new lesson. Early distributed transaction systems attempted global coordination for every operation and failed under real-world load. Early networks embedded policy directly into packet handling and collapsed under complexity before separating control and data planes.\nAutonomous AI systems repeat this pattern when governance is embedded directly into execution paths. Every retrieval, inference, or tool call becomes a potential bottleneck. Worse, failures propagate outward: When control slows, execution queues; when execution stalls, downstream systems misbehave. Universal mediation does not create safety. It creates fragility.\nAutonomy requires fast paths\nProduction systems survive by allowing most execution to proceed without synchronous governance. These execution flows—fast paths—operate within preauthorized envelopes of behavior. They are not ungoverned. They are bound.\nA fast path might include:\n- Routine retrieval from previously approved data domains\n- Inference using models already cleared for a task\n- Tool invocation within scoped permissions\n- Iterative reasoning steps that remain reversible\nFast paths assume that not every decision is equally risky. They rely on prior authorization, contextual constraints, and continuous observation rather than per-step approval. Crucially, fast paths are revocable. The authority that enables them is not permanent; it is conditional and can be tightened, redirected, or withdrawn based on observed behavior. This is how autonomy survives at scale—not by escaping governance but by operating within dynamically enforced bounds.\nWhere slow paths become necessary\nNot all decisions belong on fast paths. Certain moments require synchronous mediation because their consequences are irreversible or cross trust boundaries. These are slow paths.\nExamples include:\n- Actions that affect external systems or users\n- Retrieval from sensitive or regulated data domains\n- Escalation from advisory to acting authority\n- Novel tool use outside established behavior patterns\nSlow paths are not common. They are intentionally rare. Their purpose is not to supervise routine behavior but to intervene when the stakes change. Designing slow paths well requires restraint. When everything becomes a slow path, systems stall. When slow paths are absent, systems drift. The balance lies in identifying decision points where delay is acceptable because the cost of error is higher than the cost of waiting.\nObservation is continuous. Intervention is selective.\nA common misconception is that selective control implies limited visibility. In practice, the opposite is true. Control planes observe continuously. They collect behavioral telemetry, track decision sequences, and evaluate outcomes over time. What they do not do is intervene synchronously unless thresholds are crossed.\nThis separation—continuous observation, selective intervention—allows systems to learn from patterns rather than react to individual steps. Drift is detected not because a single action violated a rule, but because trajectories begin to diverge from expected behavior. Intervention becomes informed rather than reflexive.\nAI-native cloud architecture introduces new execution layers for context, orchestration, and agents, alongside a control plane that governs cost, security, and behavior without embedding policy directly into application logic. Figure 1 illustrates that most agent execution proceeds along fast paths operating within preauthorized envelopes and continuous observation. Only specific boundary crossings route through a slow-path control plane for synchronous mediation, after which execution resumes—preserving autonomy while enforcing authority.\nFeedback without blocking\nWhen intervention is required, effective systems favor feedback over interruption. Rather than halting execution outright, control planes adjust conditions by:\n- Tightening confidence thresholds\n- Reducing available tools\n- Narrowing retrieval scope\n- Redirecting execution toward human review\nThese interventions are proportional and often reversible. They shape future behavior without invalidating past work. The system continues operating, but within a narrower envelope. This approach mirrors mature control systems in other domains. Stability is achieved not through constant blocking but through measured correction. Direct interruption remains necessary in rare cases where consequences are immediate or irreversible, but it operates as an explicit override rather than the default mode of control.\nThe cost curve of control\nGovernance has a cost curve, and it matters. Synchronous control scales poorly. Every additional governed step adds latency, coordination overhead, and operational risk. As systems grow more autonomous, universal mediation becomes exponentially expensive.\nSelective control flattens that curve. By allowing fast paths to dominate and reserving slow paths for high-impact decisions, systems retain both responsiveness and authority. Governance cost grows sublinearly with autonomy, making scale feasible rather than fragile. This is the difference between control that looks good on paper and control that survives production.\nWhat changes for architects\nArchitects designing autonomous systems must rethink several assumptions:\n- Control planes regulate behavior, not approve actions.\n- Observability must capture decision context, not just events.\n- Authority becomes a runtime state, not a static configuration.\n- Safety emerges from feedback loops, not checkpoints.\nThese shifts are architectural, not procedural. They cannot be retrofitted through policy alone.\nAI agents operate over a shared context fabric that manages short-term memory, long-term embeddings, and event history. Centralizing the state enables reasoning continuity, auditability, and governance without embedding memory logic inside individual agents. Figure 2 shows how control operates as a feedback system: Continuous observation informs constraint updates that shape future execution. Direct interruption exists but as a last resort—reserved for irreversible harm rather than routine governance.\nGoverning outcomes, not steps\nThe temptation to govern every decision is understandable. It feels safer. But safety at scale does not come from seeing everything—it comes from being able to intervene when it matters.\nAutonomous AI systems remain viable only if governance evolves from step-by-step approval to outcome-oriented regulation. Fast paths preserve autonomy. Slow paths preserve trust. Feedback preserves stability. The future of AI governance is not more gates. It is better control. And control, done right, does not stop systems from acting. It ensures they can keep acting safely, even as autonomy grows.\n© 2026 O’Reilly Media, Inc. and/or Its Licensors", "url": "https://wpnews.pro/news/dispatches-from-o-reilly-fast-paths-and-slow-paths", "canonical_source": "https://stackoverflow.blog/2026/05/01/dispatches-from-o-reilly-fast-paths-and-slow-paths/", "published_at": "2026-05-01 14:00:00+00:00", "updated_at": "2026-05-18 20:04:48.160209+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "enterprise-software", "policy-regulation"], "entities": ["O'Reilly", "Stack Overflow", "O'Reilly Radar"], "alternates": {"html": "https://wpnews.pro/news/dispatches-from-o-reilly-fast-paths-and-slow-paths", "markdown": "https://wpnews.pro/news/dispatches-from-o-reilly-fast-paths-and-slow-paths.md", "text": "https://wpnews.pro/news/dispatches-from-o-reilly-fast-paths-and-slow-paths.txt", "jsonld": "https://wpnews.pro/news/dispatches-from-o-reilly-fast-paths-and-slow-paths.jsonld"}}