Architecting the AI-Native SMB: Systems Engineering, Agentic Harnesses, and the March of Nines

A Research Report Published by Jeffrey Stop

July 2026

Picture the scenario: your new AI agent nails the demo. It drafts the client email, summarizes the contract, and reconciles last month’s invoices flawlessly, right in front of you. Confident, you put it to work on a real operation — unattended compliance audits, multi-stage customer onboarding, financial reconciliation running in the background. Within days it’s skipping steps, inventing figures, and quietly creating cleanup work. Nothing about the model changed. What changed is that it left the demo.

Every small business hits this wall on the way to becoming AI-native. In the early phases of adoption, organizations are captivated by the illusion of the demonstration—a highly controlled environment where a large language model seamlessly drafts an email, summarizes a document, or generates a rudimentary block of code(1). The moment those same probabilistic models enter core operational workflows, the vast chasm between a successful demonstration and a reliable production system becomes painfully apparent(1).

Closing that gap isn’t a matter of buying a bigger model or writing a longer prompt. Achieving enterprise-grade reliability does not stem from simply procuring larger models with more parameters or feeding those models increasingly convoluted text instructions. Instead, it requires surrounding the foundational model with a robust, deterministic infrastructure—the same discipline that lets enterprise engineering teams ship reliable software on top of unreliable, probabilistic components.

This report translates that discipline for small businesses. It applies two time-tested systems engineering frameworks—the OODA(5) loop and the PDCA(6) cycle—to modern AI concepts including Harness Engineering, Loop Engineering, and the Model Context Protocol, showing exactly how unpredictable text generators become dependable, autonomous agents. By the end, you’ll have a concrete picture of how small businesses—from local retail shops to professional services firms—can construct reliable, automated systems capable of surviving the demands of real-world operations, plus a strategic implementation path for your own business.

The Reliability Imperative: Conquering the March of Nines

The most critical barrier to deploying autonomous systems in business environments is the pursuit of reliability, a challenge formally characterized in software engineering as the “march of nines”—a term popularized by AI researcher and former OpenAI/Tesla AI lead Andrej Karpathy(2). In reliability engineering, achieving a system that functions correctly ninety percent of the time represents the first “nine.” Progressing to ninety-nine percent (two nines), ninety-nine point nine percent (three nines), and beyond requires exponentially increasing effort. Every additional nine demands as much engineering rigor as all the previous nines combined, as progress slows while reliability compounds.

In a controlled demonstration, a ninety percent success rate feels magical. In a production business environment where errors carry financial or legal consequences, a ninety percent success rate is a catastrophic liability(3). This vulnerability is severely amplified by the nature of autonomous workflows, which rely on sequential, multi-step operations.

When an agent executes a complex enterprise workflow, failure rates compound mathematically rather than staying fixed at the per-step rate. For example, a ten-step agentic compliance audit in which each individual step has a ninety percent probability of success will complete the entire workflow successfully only 34.87% of the time—meaning nearly two out of every three end-to-end runs fail before ever reaching a human for review(1)(3). The probabilities multiply, leading to rapid systemic degradation.

March of Nines Reliability Chart

To cross this chasm, businesses cannot rely on probabilistic model outputs alone. The march of nines is conquered through deterministic systems engineering. Reliability requires bounding workflows, implementing strict interfaces, designing resilient dependencies, and establishing fast operational feedback mechanisms to detect, contain, and correct errors before they reach the end user(1).

Systems Engineering Foundations: OODA and PDCA

To build systems capable of surviving the march of nines, developers must look to established operational methodologies. Two frameworks—the OODA loop and the PDCA cycle—perfectly describe the dual nature of artificial intelligence architecture.

Tactical Execution: The OODA Loop

Originally developed by military strategist John Boyd for real-time combat decision-making, the OODA loop (Observe, Orient, Decide, Act)(5) represents the real-time cognitive process of an autonomous entity adapting to a dynamic environment. In digital architecture, this maps closely onto the “ReAct” (Reason and Act) pattern that governs how an agent interacts with its surrounding infrastructure(4). The agent Observes raw data, Orients itself using standard operating procedures, Decides on a tool to use, and Acts by executing that tool. This cycle forms the foundational reasoning-and-acting loop that drives immediate digital labor.

Strategic Optimization: The PDCA Cycle

While the OODA loop handles micro-level task execution, the PDCA cycle (Plan, Do, Check, Act)(6) handles macro-level system optimization. Language models are probabilistic; the PDCA cycle is how engineers permanently eliminate classes of errors. In modern AI systems, the PDCA cycle is increasingly automated by running analysis agents over historical execution logs to detect failure patterns, subsequently updating the underlying system prompts and guardrails so errors are never repeated(12)—a pattern explored in depth later in this report as the “Hill Climbing Loop.”

OODA and PDCA Frameworks

Deconstructing the Autonomous System: Core Components

A comprehensive understanding of Prompts, Skills, Scripts, Hooks, Plugins, and Agents is mandatory for transitioning to an AI-native operation.

Agent Harness Diagram

Prompts: The Foundation of Immediate Intent

A prompt is the most basic unit of interaction with a language model, best suited for single-shot, non-repeatable tasks(7). However, over-indexing on prompts is an architectural failure. Relying on human operators to continually rewrite complex prompts by hand generates hours of wasted effort and severe deviations in output quality(7).

Skills: Codifying Procedural Knowledge

When a task transitions to a repeatable business process, it can be upgraded to a Skill. A Skill is a reusable unit of domain knowledge and procedural logic, typically codified in a structured Markdown document(7). A Skill teaches a system exactly how to perform a workflow according to strict organizational standards (e.g., a specific methodology for reviewing marketing copy). Skills encode an organization’s own engineering taste directly into the agent’s context, anchoring the “Orient” phase of the OODA loop described above.

Scripts and Hooks: Enforcing Absolute Determinism

Models are probabilistic prediction engines; they should never be trusted with tasks that require absolute, mathematical determinism. This operational gap is filled by Scripts and Hooks.

Scripts: Deterministic lines of code executed by the overarching system. If code needs formatting, the system runs a formatting script; it does not ask the model to format it.
Hooks: Automated interception mechanisms strategically placed within the workflow. They pause the agent’s OODA loop, execute a computational check (like a schema validation), and either permit the agent to proceed or force it to halt and correct a detected error.

Plugins: Encapsulating Complete Workflows

A Plugin is the comprehensive architectural wrapper that binds Prompts, Skills, Scripts, and Hooks into a unified, distributable workflow. A plugin takes a complex workflow—such as weekly financial reporting—and gives it a name, making it an installable package that entire teams can utilize without manually reconstructing the environment.

Agents: The Synthesis of Cognition and Capability

An Agent is the holistic synthesis of the model and its surrounding infrastructure. It is a cohesive system capable of executing the OODA loop autonomously: reading context, formulating a strategic plan, utilizing tools, and evaluating its own progress. Advanced systems utilize multi-agent architectures, such as pairing a “Generator” agent with an “Evaluator” agent, where the Evaluator physically navigates generated outputs and forces the Generator to pivot if strict quality criteria are not met. At Jeffrey Stop, this pattern is embedded directly in our own production stack—our daily AI news engine runs a coordinated team of specialized agents (Content Strategist, Workflow Engineer, Static-Site Architect, and Quality & Resilience) that write, review, publish, and maintain themselves for less than $0.33/day(16).

The Universal Integration Standard: Model Context Protocol (MCP)

Model Context Protocol

To eradicate the bottleneck of building custom API connectors for every new data source, Anthropic introduced the Model Context Protocol (MCP) in late 2024(13). MCP functions as a universal adapter—much like a USB-C port for digital intelligence—standardizing how models connect to external tools and data repositories.

Through this protocol, MCP servers expose tools and live data directly to the host model. By standardizing these interactions, MCP heavily mitigates hallucinations by providing the model with direct, verified access to ground-truth organizational data (e.g., pulling live customer names directly from a CRM rather than relying on the model’s memory)(14).

Harness Engineering: Constructing the Operational Environment

The fundamental equation of modern autonomous systems design dictates that: Agent = Model + Harness(8).

Agentic Harness Engineering Diagram

Harness Engineering is the rigorous discipline of designing the execution environment surrounding the cognitive model(9). Just as heavy machinery amplifies physical labor, the harness amplifies the model’s cognitive labor by providing the durable memory, execution sandboxes, MCP integrations, and rigid guardrails that keep the model focused and productive(9)(10).

The operating principle of a fully realized harness is simple: humans steer, agents execute. A small internal team at OpenAI has reportedly run a production system that generated over one million lines of code with zero human-written and zero human-reviewed commits, relying entirely on harness-enforced review and testing loops in place of manual code review(11). Because the generation of code is now effectively free, human attention has become the critically scarce resource, and software production must be designed for agent legibility as much as human legibility.

Elite harnesses combat the inherent limitations of models—such as “context anxiety,” where a model prematurely attempts to conclude a task as its memory window fills up(10). Rather than keeping thousands of lines of execution history in the active context window, the harness mandates that the agent write its progress to physical text files on the disk, executing a “context reset” to clear the agent’s memory entirely before initiating a fresh session.

Loop Engineering: Stacking Cycles of Autonomy

If Harness Engineering defines the spatial and structural environment of the agent, Loop Engineering defines its temporal execution strategy. True autonomy, capable of scaling across an enterprise, is achieved through stacked, continuous execution loops. According to LangChain’s framework for agent design, loop engineering architecture can be categorized into four distinct, nested levels(12).

Loop Engineering Architecture

Level 1: The Agent Loop

This is the fundamental ReAct cycle. The model calls tools repeatedly until a micro-task is complete, directly powering the immediate mechanical labor of the system.

Level 2: The Verification Loop

Because the Agent Loop is susceptible to self-evaluation bias, it is wrapped in a Verification Loop. Once the agent declares a task complete, this secondary loop scores the output against an inflexible rubric. If the output fails, it is retried with direct feedback injected into the loop, ensuring quality and correctness.

Level 3: The Event-Driven Loop

Agents cannot operate in a vacuum. The Event-Driven Loop uses cron schedules, webhooks, or system events to trigger agent runs that update real systems in the background, facilitating automated work at scale without manual invocation.

Level 4: The Hill Climbing Loop

The highest level of loop engineering automates the PDCA cycle itself. Every time the inner loops execute, the harness generates detailed trace logs. The Hill Climbing Loop runs an analysis agent over these production traces to identify failures and automatically update the harness configuration, ensuring continuous, compounding system improvements.

The Recursive Execution Pattern

A highly effective synthesis of these loops—known in the developer community as the “Ralph” pattern—is the recursive execution pattern(15). In this methodology, the agent runs in an isolated loop, reads a strict plan file, selects exactly one pending task, implements the change, updates the progress document, and then fully terminates its session. The system immediately spawns a new session with an entirely fresh context window to pick up the next task, eradicating context rot and guaranteeing highly reliable, incremental progress without human supervision.

Strategic Implementation for the AI-Native Small Business

AI-Native SMB

For a small business owner transitioning to an AI-native operational model, mastering the interplay of these engineering concepts marks the difference between a frustrating novelty project and a highly profitable, scalable digital workforce.

The implementation strategy begins by completely abandoning reliance on generic, manual prompting. Institutional process knowledge must be extracted from the minds of key employees and codified into rigid, Markdown-based Skills(7).

Second, the organization must identify where probabilistic models are currently failing. If the deployed AI is generating inaccurate reports, the business must implement deterministic Scripts and verification Hooks to intercept the work before it is finalized. The operational standard must be absolute: models are utilized strictly for cognition; scripts are utilized strictly for validation.

Third, the business must treat context management as its own discipline — not just what data reaches the model in a single call, but what state and memory persist across an entire workflow. This means deploying standardized access layers like Model Context Protocol servers(17), paired with the same disciplined context resets described above, so agents work from live ground truth instead of a decaying context window.

Finally, these engineered components must be bundled into cohesive Plugins and deployed within an advanced Harness utilizing multi-layered Loop Engineering(12).

This is not a theoretical exercise for us. Our own Agentic Memory Bank System applies these same harness and coordination principles to multi-agent development environments, and it’s the same discipline behind 1M+ lines of AI-augmented code we’ve shipped to production. JS Agentic packages this exact architecture—harness, hooks, and loop engineering included—into a no-code deployment small business owners can stand up in under 30 minutes.

Conclusion

The deployment of generative artificial intelligence within a commercial enterprise is fundamentally a rigorous systems engineering challenge. The raw cognitive intelligence of large language models is profound, but without rigid architectural structure, it remains unpredictable and operationally dangerous. Bridging the gap between a successful prototype and a production-ready system requires climbing the march of nines through intense operational discipline.

By internalizing the necessity of surrounding probabilistic models with deterministic infrastructure, businesses can build systems that thrive. Harness Engineering provides the safe operational environment; Loop Engineering dictates the autonomous rhythm of execution; and universal standards like the Model Context Protocol ensure secure access to organizational data. When fragile Prompts are upgraded to durable Skills, validated by Scripts, guided by Hooks, and bundled into Plugins, the result is a truly autonomous agent capable of driving massive operational leverage. The AI-native small business is built today by engineering smarter, safer, and more reliable systems.

Want help architecting a reliable agentic system for your business? Let’s talk.