Dollhouse Research Infrastructure and applied AI systems

Welcome to Dollhouse Research and DollhouseMCP 2.0

Today is a big one.

Dollhouse Research is the new public home for a growing body of work around DollhouseMCP, Dollhouse elements, MCP-AQL, and a broader set of tools for building with AI in a way that is more composable, more understandable, and a lot less brittle.

The short version is this: Dollhouse gives you building blocks for customizing AI.

You can give your AI a persona, a specialty, a set of reusable Dollhouse Skills, a memory or many memories, ways of formatting documents, a permissions system, and coordinated ensembles that use all of those together. You can keep building upward from there until you have a real stack that behaves more like an application than a prompt. And you can build that in minutes or hours, not weeks.

Dollhouse Research is the public home for all of this work, bringing together our protocols, research, and tools. The goal is simple: make AI systems incredibly easy to use while also making them more powerful. Even more important, we built DollhouseMCP 2.0 and MCP-AQL so the LLMs themselves have a much easier time understanding what they need to do when they need to do it.

What DollhouseMCP Actually Does

DollhouseMCP is an MCP server built around reusable elements.

Those elements are human-readable files with YAML front matter and Markdown bodies. You can open them directly and understand what they do without digging through some opaque internal format.

Those building blocks include:

And yes, you can compose these further. You can have ensembles of ensembles. You can activate pieces only when you need them. You can build stacks of elements that solve real problems without front-loading everything into one giant prompt.

That composability matters a lot.

What Is New In DollhouseMCP 2.0

There is a lot in the 2.0 release, but a few things matter immediately.

We now have a built-in web server, which gives us a much more graphical and interactive way to browse portfolios, elements, and system state than trying to do everything through prompt text alone.

We also have a much stronger permission model tied directly to active elements.

If you assign a persona that is only allowed to work on frontend code, the server can enforce that programmatically. It can allow access to frontend folders and deny access to everything else. The LLM is not just being politely asked to behave. It can be hard-stopped based on the permissions declared in the active elements.

We also built the system so properties, tags, and related capabilities can load progressively. Clients do not always have to read the entire contents of every file just to figure out what is available. Because the files are structured and human-readable, we can inspect them in stages and save a lot of tokens.

Why The Agents Matter

The agents in Dollhouse are one of the things I am most excited about.

Half of the loop lives in the LLM as it works toward a goal. Then the MCP server takes over to manage permissions, capabilities, state, and any programmatic processes that need to happen. Then control goes back to the LLM for the next step.

That means agents are not just the LLM talking to itself all the time.

Getting an agent to behave also does not depend on pleading with it in prompt language. We have programmatic tools that can lock an agent down while it is working. We have programmatic tools that can warn it when it is doing the wrong thing. We have programmatic tools that can simply stop it if it tries to do something truly dangerous. Frankly, I am still shocked that other much larger companies have not built more of this into their products.

It also means an agent can wait for input with zero token usage while the server side holds the state. That is a big deal.

Why MCP-AQL Matters

DollhouseMCP is the first MCP server being built natively with MCP-AQL as its tool-calling protocol.

The simple version is this: instead of exposing a giant pile of separate tools, MCP-AQL gives the model a semantic set of endpoints:

That turns classic CRUD into CRUDE and gives the LLM a much better first understanding of what kind of action it is trying to take.

If it wants to inspect something, it goes to read. If it wants to create something, it goes to create. If it wants to run an agent or another runtime action, it goes to execute.

Under each endpoint, dozens of operations can run through a single protocol pattern. It is closer in spirit to GraphQL than to the traditional “everything is a separate tool” model.

That gives us a few major benefits:

If the model makes the wrong call, it can introspect.

If it passes the wrong parameters, the error response can tell it what it did wrong and how to fix it.

That is a much better loop than hoping it remembers a huge tool surface perfectly every time.

We Tried To Make Onboarding Much Less Painful

Personally, I really hate the normal MCP server installation experience.

Pasting in JSON by hand is annoying. It is tedious. It is error-prone. And at this point it is ridiculous. MCP has been around long enough, and we have more than enough programmatic tools available, that we should not still be doing setup this way.

I get indentation wrong often enough that I finally got tired of dealing with it. So I put a lot of effort into making DollhouseMCP easier to install than most MCP servers.

The new one-liner is:

npx @dollhousemcp/mcp-server@latest --web

Copy this. Run it in a terminal. DollhouseMCP will open a browser with the installation tools right there for the popular AI MCP clients on your local machine.

For Claude Code, it is still a single command. For Claude Desktop, the .mcpb extension path makes installation dramatically easier than hand-editing config files. And yes, I am very grateful to the people who have been making MCP installation tooling better, because that made it much easier for us to reduce the usual setup pain here too.

And specifically, thank you to Dhravya Shah: https://github.com/Dhravya and to install-mcp: https://github.com/supermemoryai/install-mcp. That project is genuinely useful. It is published through the supermemoryai organization under the MIT license, and work like that makes the whole MCP ecosystem easier to use for everyone.

If other MCP servers copy that onboarding flow, I will be thrilled.

Seriously. Please do.

I want installing MCP servers to get dramatically easier across the board, and I want more servers to adopt MCP-AQL or ideas like it so we can stop wasting context on tool bloat and start letting people install more useful things at once.

DollhouseMCP Is A Regular MCP Server

DollhouseMCP works with any MCP client.

That means the portfolio content you create locally, your personas, your Dollhouse Skills, your memories, your templates, your ensembles, and your agents live on your machine and move with you. You are not locked into one AI company or one client feature set.

Portability is a huge deal. If one AI platform gets better, you can move. If another one gets worse, you can move. If you want to use multiple platforms with the same DollhouseMCP setup, you can do that too. In many cases, that can be incredibly useful.

And when a client supports richer behavior, we do take advantage of that as well. Claude Code is a good example, especially around passing through and honoring permission-related properties. We are working to make those integrations stronger across more platforms without making the basic MCP path any harder.

Licensing

DollhouseMCP is AGPL.

If you want to study it, modify it, build on it, and share your changes, great. Please do. Attribution matters, and sharing modifications matters, but I want people to use this work.

We are also offering a commercial license path.

If you are making under one million dollars a year in revenue, the commercial tier is free. Hobbyists and small builders should be covered. If you are over that threshold, contact me directly at mick@dollhousemcp.com.

We will automate more of that licensing flow soon. For now, just reach out.

Give It A Try

This release represents a lot of work, and it opens the door to a lot more.

Dollhouse Research is the new public home for that broader effort. DollhouseMCP 2.0 is the platform foundation. The Dollhouse Collection gives the elements a public home. MCP-AQL gives us a protocol that scales much better than the usual MCP tool sprawl.

There is more coming right behind this, but this is already a very real release and a very real starting point.

Give it a try. Pull it apart. Build on it. If something is great, tell me. If something is rough, definitely tell me.

Go build things that build things.