Stop Trusting Your Agent Framework. Start Controlling It.

Most agent frameworks hide their inner workings, presenting a black box to users. You provide a model and a prompt, and the framework handles the reasoning, tool selection, and context management internally. This can lead to debugging difficulties when things go wrong, as the system is not designed to be easily inspected or modified.

Reactive Agents, an open-source TypeScript framework, takes a different approach. It emphasizes control and visibility, making it clear what is happening behind the scenes. The framework is built on the premise that the engineering around the model, not the model itself, determines an agent's reliability. This philosophy is reflected in the framework's design, which exposes all aspects of the agent's operation and allows users to shape and customize the engineering components.

The framework's core idea is that nothing runs that you didn't explicitly request. When you build an agent using Reactive Agents, you control every aspect of its behavior through a series of `.with()` calls. Each call turns on a specific feature, such as memory management, tool integration, or reasoning capabilities. You have full control over which aspects are activated, ensuring that the agent behaves exactly as you intend.

The framework's design is centered around the idea that the harness, or the engineering around the model, is what makes an agent truly effective. It breaks down the agent's operation into a series of named phases, each with its own set of hooks that can be customized. This structured lifecycle includes bootstrap, guardrail, cost-route, think, act, observe, and verify, among others.

By providing explicit hooks at each stage, Reactive Agents ensures that users have full visibility into the agent's behavior and can intervene or modify the process as needed. This transparency is a key differentiator from other agent frameworks, which often operate in a more opaque manner. The framework's architecture also emphasizes adaptability.

Different models can be used interchangeably, and the framework includes features like model-adaptive context profiles and a healing pipeline to optimize performance based on the model's capabilities. For instance, smaller models may benefit from enhanced context profiles that reduce prompt noise, while a healing pipeline can catch and correct errors that smaller models might make.

This adaptability allows users to leverage the strengths of various models without sacrificing control or reliability. In summary, Reactive Agents provides a clear, open, and customizable framework for building agents. By focusing on visible engineering and user control, it addresses common issues found in other agent frameworks, such as hidden complexities and lack of transparency.

The result is a more reliable and maintainable approach to agent development, where users can confidently build and iterate on agents using a model that fits their needs and resources.