The studio, machine-readable.

Hello from Corduroy Labs.

This week we spent a couple of afternoons doing something small and unglamorous: we made the studio's website machine-readable.

Not more readable. The site was already readable in a browser. We made it readable by the other kind of reader — the kind that increasingly matters. RSS readers. JSON Feed aggregators. Language models. Agent runtimes. The audience that shows up without a browser.

Four small shipments, one theme.

Four surfaces, one substrate

The studio now publishes four machine-readable surfaces at four canonical URLs.

/feed.xml is a classic RSS 2.0 feed. It carries the updates page's posts, newest first, with a full HTML body and the hero image attached via the media:content extension. Every RSS reader and podcast-style aggregator can pick it up. The installed base is huge. This is the polite ground floor.

/feed.json is a JSON Feed 1.1 document. Same posts, same order, same body. The reason to also ship it is that modern aggregators, JavaScript-native reader apps, and AI feed-summarizers can parse JSON in five lines of code, and RSS in ten times that with an XML dependency. If a reader was written in the last three years, it probably prefers this format. Shipping both was a decision to serve every audience without picking one.

/llms.txt is a markdown map. It follows the llmstxt.org spec — one H1 title, a blockquote summary, and short sections linking to the most important pages with a one-line gloss for each. It is not a feed. It is a table of contents for a language model showing up on our site for the first time. Whether the major crawlers respect it today is still an open question; adoption is early. We shipped it anyway. Some of the audiences we care about are model-shaped, and a five-minute file that speaks their language is not a hard call.

corduroy-labs.ai/mcp is a small Model Context Protocol server. It exposes exactly two tools — list_updates and get_update — over MCP's modern streamable-HTTP transport. Any MCP client (Claude Desktop, Cursor, Codex, n8n's MCP node, and everything downstream) can now query the studio's updates conversationally without touching a browser.

The MCP server is a demonstration

The MCP server is the piece we want to be honest about.

It is not a database. It is not a search engine. It does not do anything that a well-written HTTP client could not do with our JSON Feed and twenty lines of Python. The server itself just reads /feed.json every five minutes and re-exposes it through MCP's protocol shape. That is the whole implementation.

The point is what that implementation says.

Any site that publishes JSON Feed already has an MCP-shaped surface. The MCP server is the projection layer that makes it visible. That is the pattern we wanted a working example of, both for ourselves and for anyone who reads this post and thinks about the small operator's website they run.

Shipping the JSON Feed was the actual work. The MCP server is the punchline.

Public, rate-limited, no auth

The endpoint lives at corduroy-labs.ai/mcp — on the same public vhost as the RSS and JSON Feed, not behind our admin oauth gate. That is deliberate. The tools are a thin projection over an already-public feed, so putting auth in front of them would only break every headless MCP client without protecting anything of substance.

We rate-limit at sixty requests per hour per IP, in the MCP server process itself. That keeps costs bounded even under scanner traffic without any additional infrastructure. If you want a higher ceiling for a specific integration, get in touch.

Why bother, at a small studio

You could reasonably ask: your updates page already renders in a browser. People can read it. Why bother teaching an agent to fetch the same thing a different way?

Two reasons.

The first is that we do not know, up front, who or what is going to read the studio next. Every year, more of the arriving reader is a machine — sometimes a scraper, sometimes an AI aggregator making a summary for a human, sometimes an agent working on behalf of a specific operator with a specific question. Optimizing only for the browser reader increasingly leaves value on the table. This isn't philosophy; it's a shift already visible in our own site's server logs.

The second reason is closer to the studio's actual work. We build agent-first foundations on open systems. Our own website is the first system we owe that treatment to. If our site is opaque to agents, we are not walking our own line. Machine-readability is not a nice-to-have for a studio in this business. It is basic hygiene.

A word about the flywheel

Everything above ships as a public artifact.

The RSS and JSON Feed files are served from the site itself. The llms.txt is public at the root. The MCP server's source code is a small Python package under an MIT license, published as a tarball on this site. The whole thing is small enough that a founder building their own site can read it in an afternoon and adapt it.

The core is roughly this — the JSON Feed already carries every field we need, so the MCP server is a thin projection over it:

import httpx
from mcp.server.fastmcp import FastMCP

FEED = "https://corduroy-labs.ai/feed.json"
mcp = FastMCP("corduroy-labs")

@mcp.tool()
def list_updates(limit: int | None = None):
    items = httpx.get(FEED).json()["items"]
    return items[:limit] if limit else items

@mcp.tool()
def get_update(slug: str):
    for item in httpx.get(FEED).json()["items"]:
        if slug in item["url"]:
            return item
    raise ValueError(f"no update with slug {slug!r}")

if __name__ == "__main__":
    mcp.run(transport="streamable-http")

That's the whole idea. The shipped version adds a small cache, better slug parsing, and clearer errors, but the shape is unchanged. That is the flywheel we care about: the artifact is the marketing.

If you run a small business site and want to be findable, readable, and queryable by the machines that will increasingly arrive on your doorstep, the substrate is smaller than you think. Feed the browser, feed the reader apps, feed the crawlers, feed the agents — all off one canonical set of posts. That's it.

That is the pattern. The rest is small careful engineering.