man-looking-at-butterfly.jpeg is this recursive

You can just delegate things.Or, Help me, help you, help me.Or, If ${this.app} only had a brain.

What if the app was the agent harness, and MCP let it borrow the agent’s judgment exactly when it needed some?

September 1, 2026From the Oa Hai! Lab

We typically look at MCP servers like a remote. Here are my tools, the contract, a way to get you some state. Good luck, Agent!

This is a powerful interface & abstraction over applications. With it I can give my agent a remote to operate my apps, configure them, connect them to other apps. But do you remember those super TV/everything remotes, with like 1000 buttons? They looked powerful, but you needed to take a college course to operate, and then you needed a pretty good memory.

Anyways, big MCP surfaces can become like those everything remotes from the 80s / 90s (maybe they still exist?). Worse, they let an agent declare victory early and wake you from your mid-afternoon snooze only to find they confidently hallucinated doneness.

Oof, the agent becomes the app harness, owns the loop, remembers state, chooses what to do next, and decides when it’s done enough.

What if we flipped the roles around? What if the app could become a harness around the agent for the current goal? By doing what it can - and borrowing the agent’s brain for the parts it can’t. I mean, every app that needs input borrows judgement from someone/thing/where.

Ok, the fun part.

Disclaimer for what lies ahead: There are reasons to do this, and reasons not to. Those trade-offs are for you to juggle.

Independent app. It remembers this article when it finishes.Open prototype separately View source

Your app may not always need the users or a brain of its own. It may only need a way to pause and ask for judgement, and a nice abstraction over where it comes from, the caller, the user, or your LLM of choice. How? Your app can delegate judgement to the MCP calling agent.

Imagine an app that makes a flip book animation (this is a toy example, not perfect 1:1 application to a CRM/design tool/configurator whatever, please, forgive me).

The user asks: Make me a 12-frame flipbook where two people are walking dogs, meet over some circumstance, and fall in love.

The agent calls a single MCP tool.

The app responds with it’s own question (And a way to answer it)

The agent answers the question in the next call of the same tool

This continues until everyone has what they want.


Goal
 -> Tool call
 -> Validation & Question Response
 -> Answer Tool Call
 -> Validation & Question Response
 -> Answer Tool Call / Give Control back to user / Done

How do you make it reliable? DSPy. Every delegated request is encouraged by DSPy style compiled programs to behave.

Is this an RLM? No, but I like them.