The Agent Illusion

You are an agent. So am I.

We perceive, interpret, plan, and act intentionally within our world. That's agency.

Modern Large Language Models (LLMs) like ChatGPT learn patterns that look like agency. They can discuss plans, even outline steps. But translating that text into reliable action is where things often break down.

Discussions of consciousness are fascinating, yet beyond our immediate scope. What we are asking isn’t philosophical; but a practical engineering challenge.

Offloading digital chores seems to exist only in advertising. Instead of genuine innovation, the reality we often receive is the simple made complex, and the complex "a few years away." We're sold agents but delivered puppets stumbling over their invisible strings - the illusion of agency.

The Proxy Base Agent is different.

A rule is a way of structuring awareness.

— Rick Rubin, The Creative Act: A Way of Being

Rules shape awareness, and awareness shapes action.

The Proxy Base Agent (PBA) acts as a mechanical continuation of the neural network itself. The PBA uses the Proxy Structuring Engine to dynamically shape the LLM through explicit structures and stateful control (read our post Saddle the Bull for more).

The PBA defines the agent's process as a Hierarchical State Machine (HSM). During generation, the PSE uses the HSM to guarantee the LLM only generates valid transitions between states and produces structurally correct output within each state (like perfectly formatted tool calls). This runtime enforcement transforms the LLM from a freeform predictor into a reliable, process-driven actor.

The base agent unlocks deterministic work and reliable execution. By defining the agent's process as an explicit state machine, you can dictate the sequence of operations (e.g., Observe ➔ Plan ➔ Act) with multiple layers of abstraction. This mechanical approach is both inspectable, traceable, and scalable.

We designed the PBA to be model-agnostic; working as a modular, configurable chassis: providing the state management and execution guarantees without locking you into a single vendor or model. The reliable execution framework is separate from the underlying intelligence, giving you flexibility without sacrificing dependability.

Beyond reliability, the PBA enables dynamic adaptation through the Model Context Protocol (MCP). Agents can connect to external MCP servers on the fly, instantly gaining access to new tools, capabilities, and information. The PBA dynamically updates the structure of its internal HSM, ensuring these new tools are immediately usable in the current context. This allows agents to adapt their skillset on demand, a capability impossible with static agent definitions or prompt chaining libraries.

This reliable, traceable execution isn't confined to abstract tasks. It's the prerequisite for agents that can reliably interact with complex environments.

Imagine defining an HSM for visual interaction: LookAtScreen (use a tool) → ProcessVisualSchema → PlanInteraction → ExecuteMouseClick (another tool). Because each step's structure and transition is guaranteed, you can build agents that navigate GUIs or interact with visual data sources with unprecedented dependability.

The combination of the PSE and PBA create a foundational unit, and its dynamic MCP adaptability unlocks scalable specialization. Think beyond monolithic agents. Deploy lightweight, specialized PBA instances on demand: one connects via MCP to manage your music, another to interface with scheduling APIs, a third for integrating external LLMs like ChatGPT or Gemini.

A local "manager" agent could orchestrate complex workflows across multiple specialized sub-units. Because the PBA is designed for local execution (consumer hardware, enterprise servers, etc.) and can reliably manage complex state via its HSM, it enables deep personalization. This means agents deeply tailored to individual needs – a personal health tracker integrating securely with local data, a writing partner remembering private project details – without constantly leaking context to external services.

Ultimately, this architecture redefines what it means to delegate tasks to AI. The inspectable, traceable, and reliable nature of PBA's execution builds trust. When an agent follows an explicit, enforced state machine and uses tools with guaranteed structural correctness, you move from hoping it works to knowing it follows the process.

This confidence allows delegation of increasingly complex, multi-step tasks – managing communications, coordinating projects, interacting with external systems – that were previously unthinkable due to the inherent unreliability of other approaches.

The Proxy Base Agent is the engineered foundation needed to move beyond the agent illusion. By enforcing stateful execution and guaranteeing structural reliability, these dependable agentic systems are now a reality.

See the full breakdown on the main Proxy Base Agent page.

The core library is open source on GitHub, ready for you to build with. Dive into the technical documentation for details and guides, or explore our Business Services for expert guidance and commercial opportunities.

The path forward is vertical.