Composable Agents

Happy New Year! After a few quiet months in build mode, Modulewise is kicking off 2026 by scheduling demo sessions for potential team members, advisors, design partners, and others in the community who are interested in providing feedback. This post provides a quick glimpse of what’s being shown in the demos.

Previous posts described how the Modulewise Toolbelt enables composable tools for agents. That work will continue, with updates to the latest Model Context Protocol (MCP) spec as well as several new areas of functionality related to security and observability. But the past few months of building have revealed that the composable model extends very well to agents themselves. In fact, the central theme of focusing on differentiated domain-specific value while reusing components for the undifferentiated parts is even more relevant when building agents. Also more relevant: the zero-trust execution environment and the least-privilege capability model.

Modulewise Agent Studio

This is a rapidly evolving work-in-progress, but at the time of writing, the Modulewise Agent Studio includes:

• Agent Console: a Web UI with an Agent view as depicted above and a Skills view for curating Agent Skills along with associated Tools
• Agent Loop: an A2A Server powered by Rig and the Wasm Component Model
• Control Plane: a REST API for managing the catalog of Agents and Skills, the registry of Components, and the deployment lifecycle of each Agent Loop

The layout of the Agent Console was inspired by digital audio workstation (DAW) software. In the Agent view, each agent has a “track” and each track is “polyphonic”. The Agent Loop embeds the same Wasm Component runtime as the Modulewise Toolbelt. The rest of this post will focus on customizing the Agent Loop through composition.

The Agent Loop

The reason the composable model applies not just to tools but also to agents is because agents share a common algorithmic skeleton. The “agent loop” is the new infrastructure, and because it is hosting unpredictable behavior, it is more important than ever to have a solid, reusable foundation for managing cross-cutting concerns related to security, observability, and durability.

The simplest case looks like this:

For an Agent that simple, all that’s needed in the Agent Console is to select a model and specify a system prompt (NO CODE). And if you accept the defaults, it means just 2-clicks to a running Agent.

That said, each instance of an Agent Loop should be fully configurable: language model, system prompt, temperature, token budget, etc. A more complex example may also include calling tools and/or other agents:

Despite increased complexity, the case for a reusable agent loop is even stronger here. The differentiated business value lives in the APIs and data sources exposed via tools. All of the code that processes request messages, interacts with the language model, calls the tools, and delegates to the sub-agents is handled within the Modulewise Agent Loop. The parts that are pluggable are based on standard formats: Agent Skills, MCP Tool Definitions, A2A Agent Cards, etc.

And yet sometimes that is not enough. Custom code might be needed at different parts of the loop, not merely through the shapes offered by those standards. Good news: this is where the composable model truly shines.

Interception as a Superpower

The Modulewise Agent Loop supports Interceptors to ensure that any potential need for custom code can be supported through a comprehensive yet focused set of extension points.

For those familiar with Aspect Oriented Programming (AOP), these extension points represent where “advice” can be applied before, after, or around each “joinpoint” that might require customization through code. Rather than coding a full agent loop of your own, you simply implement one or more of the pre-defined interfaces that represent each of those extension points.

There will also be several Modulewise-provided interceptors addressing common cross-cutting concerns such as enabling observability through distributed tracing, applying fine-grained authorization policies for tool calls, or adding retries with a backoff policy. So you can mix-and-match those provided interceptors (blue) with your own (green) in any combination.

Each Interceptor is a Wasm Component that is actually composed into the single Agent component. There is no remote procedure call or network hop across the internal component boundaries, only local function calls. Since Wasm is a bytecode compile target, that is true even if Interceptors are implemented in different programming languages! And finally, Modulewise will provide generators for scaffolding the Interceptor code across multiple languages. Those will share a common foundation with the Toolsmith used for generating Wasm Components that can surface as tools in the Modulewise Toolbelt.

Seeking Feedback

The driving vision for Modulewise is to promote composition over coding while never limiting the ability to customize. The Modulewise Agent Studio will strike that balance by providing this Agent Loop within which pluggable components allow for a full range of extensibility. When it is necessary to write code, it’s a matter of implementing well-defined interfaces that fit into the loop. If this sounds interesting, request a demo! You can find Modulewise on LinkedIn and X.