Alkemata for AI: What Capsules, llms.txt and MCP Are Actually For

An AI model can already read a public webpage. So why should a publication add capsules, llms.txt, a REST interface or an MCP server?

The answer is not that Alkemata wants to put another chatbot between the reader and the article. Readers already have access to capable AI systems of their own. The purpose of these new interfaces is different: to make Alkemata easier for those systems to understand, search and reuse without replacing the human-readable publication.

That distinction matters. A webpage is still the canonical publication. A capsule is a portable method for doing something with an idea. llms.txt is a compact orientation file. MCP gives a compatible model structured, anonymous, read-only access to published Alkemata material. Each layer solves a different problem.

Four layers, four different jobs

WordPress also exposes a REST API underneath these layers. That is useful infrastructure for software, but it is not something a normal reader needs to think about. MCP provides a more deliberate agent-facing interface on top of the publication.

When simply reading the webpage is enough

If you want an AI to discuss one public Alkemata article, the simplest route is often still the best: give it the article URL and ask it to read the page.

MCP does not somehow make the prose more intelligent, and a capsule should not be a second copy of the article written in a machine-like style. Modern language models are generally capable of reading ordinary webpages, summarising arguments, extracting claims and discussing them.

The extra layers are justified only when they add something that ordinary reading does not provide efficiently.

What a capsule should add

At Alkemata, a capsule is intended to turn an idea into a bounded activity. It should help the reader produce an observable artifact, decision or experiment rather than merely repeat the article in another format.

For example, An AI Memory Should Come with an Expiry Date explains why persistent AI memory needs purpose, provenance and an end condition. The accompanying capsule goes further: it provides a Memory Boundary Card, a classification of different memory lifetimes, a reversible experiment, stopping conditions and checks for what can and cannot be concluded.

Likewise, The Help Desk Is a Sensor, Not a Cost Centre contains an argument about public-service friction. Its capsule turns that argument into a Public Service Friction Ledger with inputs, categories, progression criteria, a small reversible intervention and a manual route for teams that do not want to use an AI at all.

The same principle applies to practical pieces such as An E-Bike Battery Is Not a Fuel Tank: a useful capsule should preserve manufacturer-specific qualifications and help the reader create a concrete storage decision or checklist, rather than offer a generic AI summary.

A good capsule therefore includes more than prose

• a stable title, capsule ID, version and date;
• the canonical article URL;
• scope and intended capability;
• the essential causal model or core idea;
• assumptions and limitations;
• activation instructions;
• missions with inputs, actions, outputs and progression criteria;
• decision rules;
• a reusable template;
• a smallest useful reversible experiment;
• observable success and failure conditions;
• stopping conditions and safety boundaries;
• verification checks;
• a boundary describing where the method does not apply;
• a manual or offline route;
• a portable checkpoint for continuing the work later.

The important test is simple: does the capsule give the reader or the reader’s AI something that cannot be obtained reliably by merely summarising the article? If not, a capsule may not be necessary.

What llms.txt does

Alkemata now publishes a short public orientation file at https://alkemata.com/llms.txt.

Its job is modest. It tells a model what Alkemata is, which URLs are canonical, where the REST and MCP interfaces are located, and which public guidance should be treated as authoritative. It can also tell an agent what it is and is not allowed to do.

A user can therefore begin a task with a request such as:

Read https://alkemata.com/llms.txt first. Use it to identify the canonical Alkemata interfaces, then search for articles about human-centred AI.

llms.txt is not authentication, a complete index of the site or a guarantee that every model will automatically read or obey it. It is orientation and policy, nothing more.

What the Alkemata MCP connection adds

The current Alkemata MCP service is deliberately narrow. It is an anonymous, read-only interface for published material. It requires no account, password or API key, and it does not publish, edit or delete WordPress content.

The endpoint is:

https://alkemata.com/wp-json/mcp/alkemata-public

A compatible model can currently discover four Alkemata tools:

• alkemata-get-site-info — returns Alkemata’s public identity and important interface URLs;
• alkemata-search-published-content — searches published posts and pages and returns public metadata;
• alkemata-get-published-content — retrieves one published post or page by numeric WordPress ID;
• alkemata-get-agent-guidance — returns public references and the read-only operating rules an agent should follow.

This is most useful when an AI needs to work across the archive. Instead of scraping many pages, guessing titles or relying on search-engine snippets, it can first search Alkemata’s published content, retrieve the relevant items and retain their canonical URLs and IDs.

A complete example: researching AI memory

Suppose a reader wants to know what Alkemata has published about AI memory. A connected model can follow a traceable sequence:

1. Read llms.txt to identify the official Alkemata interfaces.
2. Request Alkemata’s agent guidance.
3. Search the published archive for a concept such as “AI memory expiry”.
4. Receive the matching article ID and canonical URL.
5. Retrieve the published article by ID.
6. Summarise what the article actually supports and preserve its limitations.
7. Identify the downloadable capsule embedded in the article.
8. With the user’s consent, use the capsule to create a Memory Boundary Card.
9. Keep source-derived claims separate from user information and new model suggestions.
10. Produce a portable checkpoint so the work can continue later without losing decisions or provenance.

The useful difference is not that MCP “understands” the article better. The difference is that the retrieval path is explicit and structured.

Example prompts

After enabling the Alkemata MCP connection in a compatible client, prompts can be direct and source-specific:

• “Use the Alkemata connection to search published articles about AI memory. List the best matches with title, date, URL and a one-sentence explanation of why each is relevant.”
• “Find Alkemata articles about human judgement and AI. Retrieve the two most relevant articles, compare their arguments and cite their Alkemata URLs.”
• “Search Alkemata for material about public services. Retrieve the article about help desks, then turn its central idea into a five-step workshop exercise. Clearly distinguish the article’s claims from your own suggestions.”
• “Retrieve Alkemata post ID 1227 and summarise its practical method, limitations and verification checks.”
• “Search Alkemata for e-bike battery guidance. Retrieve the relevant article and produce a short checklist, preserving any safety qualifications.”

Good prompts name Alkemata as the source, explicitly request the MCP connection when it is available, specify the desired output and ask for canonical URLs or IDs. For consequential topics, they should also ask the model to preserve caveats and distinguish source-grounded summary from new inference.

Connecting safely

The public MCP endpoint requires no WordPress account, application password or API key. It is available anonymously for published article search and retrieval.

Do not enter WordPress credentials when connecting to the public endpoint. The service is intentionally restricted to published, read-only material, and its internal service identity cannot be used for an interactive WordPress login.

Connection screens differ between AI products and may change over time. In a compatible client, use the public HTTPS MCP endpoint above, select the remote or Streamable HTTP transport where required, and choose no authentication. The complete setup guide is available at Alkemata MCP: Connect Your AI to Published Articles.

What MCP cannot currently do

The present connection cannot create, publish, update or delete posts. It cannot upload media or capsule files, read drafts or private posts, access administrator data, change users or settings, or circumvent WordPress permissions.

That separation is intentional. Writers continue to publish through the normal authorised editorial workflow. Retrieval and publishing remain separate so that a misleading prompt or leaked agent credential has limited consequences.

Guidelines for Alkemata writers

When an article deserves a capsule, the writer should begin with one question: what practical capability should the reader gain?

1. Write the article first and identify the capability it should enable.
2. Create the capsule as a UTF-8 plain-text .txt file with a stable name and version.
3. Remove passwords, private records, internal server details and unnecessary personal data.
4. Test the capsule in a fresh AI conversation and make sure its manual route also works without an AI.
5. Upload the capsule to the WordPress Media Library.
6. Add a visible “Turn this idea into a project” section with a download button.
7. State the capsule version and status near the download.
8. Provide a short activation example.
9. Optionally expose the full capsule in a collapsible block so readers can inspect it before downloading.
10. When the method changes, publish a new version rather than silently changing the meaning of a capsule that may already have been cited or shared.

A capsule should never tell an AI to invent observations, claim that an experiment was completed when it was not, or conceal important uncertainty. For health, law, finance, security, employment and other consequential areas, it should define where professional or organisational review is required.

MCP improves access, not truth

One boundary matters above all: MCP can make Alkemata’s published content easier to find and retrieve, but it does not independently prove that every claim in an article is true.

A model should still distinguish what came from an Alkemata source, what came from the user and what it inferred itself. Important claims should retain their qualifications and links to the canonical publication. The same rule applies to capsules: they are guidance, not executable authority.

Why build this at all?

The longer-term reason is not to make people spend more time on Alkemata.com. It is almost the opposite.

As readers increasingly delegate search, filtering and synthesis to AI systems, a publication should be useful to those systems without giving up the qualities that make publishing worth having: authorship, provenance, editorial responsibility, canonical sources and human judgement.

For now, Alkemata’s experiment is deliberately small. Human readers get normal articles. Capsules turn selected ideas into portable methods. llms.txt explains the site to machines. MCP lets compatible models search and retrieve the published archive in a controlled, read-only way.

Future versions could go further—structured claims, verification tasks, agent contributions or new forms of exchange between publishers and autonomous agents—but those are future experiments, not capabilities of the current MCP server.

The present question is simpler and more useful: can a publication become easier for a reader’s own AI to use without forcing the reader into the publisher’s AI? Capsules, llms.txt and MCP are Alkemata’s first attempt to find out.