It only has five CRUDE endpoint: Create, Read, Update, Delete, and Execute using a GraphQL-like structure for tool calling of the operations within the endpoints. It's very efficient, and robust. there's all kinds of exemplar tools and components to make adapters for any MCP server. You don't even need to rewrite your own MCP server. Just create an adapter for it.

All open source at MCPAQL.com

And, they can say that for anybody at any time, and you'll never know why, and there's no way to prove it.

Everyone needs a flight data recorder to prove... "here's what I was actually doing and why it was not distillation." And now you're having to prove your innocence instead of them having to prove you're guilty, and really at the end of the day, it's just the model being stupid that they're protecting themselves from.

They obviously put their best model on the job to build that.

----------------------

Fable 5: Our most capable model yet Our newest model tackles your biggest challenges with fewer check-ins needed.

• Included in your plan limits until Jun 22

Fable takes 2× the usage of Opus. • Switch models when a message is flagged

When safety measures flag a message, automatically switch to a different model to keep chatting. When off, your chat will pause instead. https://support.claude.com/en/articles/15363606" target="_blank" rel="noopener noreferrer">Learn more

There's a lot of room for improving the smaller models at many levels of the stack.

Then I looked at the usage and it said I had used 95% of my Claude design usage for the week!

This isn't a real tool. This is a plaything, if that's what they're providing as examples.

DollhouseMCP 2.0 is an open-source MCP server for making and using composable building blocks for AI customization. You build elements as portable MD and YAML files, compose them into stacks, and activate the stacks in any MCP-compatible client.

Element types that drive behavior and permissions:

* Personas: behavioral profiles (how the AI sounds and acts)

* Skills: discrete capabilities (what the AI can do)

* Agents: goal-oriented, multi-step executors

* Ensembles: composed stacks of the above

* Plus templates for structured outputs and memories for persistent context.

Two things I think are actually new here:

1. Identity-based permissioning. When you activate a persona, skill, agent, or ensemble, its permission policy takes effect in the server. Same client, same LLM, different permission surface depending on which active elements are loaded. A read-only analyst persona blocks creates and deletes regardless of what the client allows. A security-focused ensemble can deny specific destructive operations. This runs server-side, after the client approves the call, so policy cannot be overridden by the LLM or the client.

2. A bimodal agent loop. Agents do not run free inside the LLM. Every step hands control back to the MCP server, which evaluates the proposed operation against the active permission stack, runs autonomy and risk checks, enforces any hard blocks, then returns a decision to the LLM with continue, pause, or escalate guidance. The LLM acts on what it is allowed to do, describes the next step, and hands back to the server. The loop repeats until the goal completes or a human is asked to intervene. Higher agency stays observable and bounded instead of opaque.

There's also a audit trail of approved and denied actions a danger zone lockout that will prevent the LLM from doing truly dangerous things if they go through the MCP server. And any active Dollhouse agent that is running through the DollhouseMCP server has it's actions evaluated every step.

I added easy configuration through the web console for a wide variety of MCP clients if you use the one-liner, and there are logs and metrics as well as the local and github hosted portfolio and collection to save your Dollhouse elements and share and use other's. They are all validated and scanned several times along the their distribution path to keep things as safe as we can.

The one-liner install: npx @dollhousemcp/mcp-server@latest --web

Happy to go deep on the permissioning model, the bimodal agent loop, composition patterns, YAML schema, or anything else.

Home: https://dollhousemcp.com Repo: https://github.com/DollhouseMCP/mcp-server Collection: https://collection.dollhousemcp.com

Hope you like it.

Comments URL: https://news.ycombinator.com/item?id=47765161

Points: 3

# Comments: 0

For me, it is having a document and interrogating it. Maybe having many sets of documents about a whole category of information. Getting the bullet points. getting the high level and then interrogating and digging down and being able to get bubbled up information as I need it.

That is the learning style that matches how I learn.

I have never been able to skim, so reading a large document WILL teach me that topic, but getting through that doc is tough.

I can dump a very large set of docs in a reader that lets me interrogate the whole data set and I can fly through looking for what is interesting to me, and what I may need, and along the way I will likely dive into other parts too. Asking questions keeps my hyperfocus active.

I think it is just a different style. I have synesthesia and a hard time not working on three to five things at once. I am use to knowing I learn differently than others.

When it comes to agents' tasks, I tend to focus on things that I couldn't do before without automated agents, at least at the going price.

The kind of automation I'm doing is more like building a set of agents to generate marketing surveys for me. They take free form input from me and my project. They aren't particularly sexy but they go off and do something valuable that I literally would never pay for at the prices that they are normally.

If I had a nice CI/CD workflow that was built into GitHub rather than rolling my own that I have running locally, that might just make it a little more automatic and a little easier.

As for the domain, this is the same account that has been hosting Github projects for more than a decade. Pretty sure it is legit. Org ID is 9,919 from 2008.

We have mechanisms for ensuring output from humans, and those are nothing like ensuring the output from a compiler. We have checks on people, we have whole industries of people whose whole careers are managing people, to manage other people, to manage other people.

with regards to predictability LLMs essentially behave like people in this manner. The same kind of checks that we use for people are needed for them, not the same kind of checks we use for software.