md2rich as a Claude Skill: Markdown to Rich Text 2026

Anthropic shipped three pieces together on August 20, 2026: a Skills API for uploading and versioning your own skills, a Files API with 1 TB of storage per organization and 5x higher rate limits, and an updated computer use tool that takes several actions per turn. The Skills API lets you package a Markdown-to-rich-text converter as a folder a Claude agent loads only when the task calls for it, runs inside Claude's code execution sandbox, and references by id on every later request.

md2rich has always been a Markdown-to-rich-text converter with one defining trait: the conversion happens in the browser, the Markdown never leaves the tab, and the rich text the platform understands comes out the other side. The Skills API matches that posture exactly. A Claude agent that needs to turn a Markdown draft into LinkedIn-ready rich text loads md2rich as a skill, runs it in the sandbox, and returns the result without calling a third-party converter. That is what a Skills API endpoint for md2rich looks like in 2026.

What the Skills API actually gives you

A skill in the Anthropic Skills API is a folder of instructions, scripts, and templates. You upload the folder once with the Skills API, version it like a package, and reference it on later Messages API requests through container.skills. When the agent decides a request needs the skill, Claude loads the folder, follows the SKILL.md, runs the script in its code execution sandbox, and returns whatever the script produces as part of the agent's response. There is nothing for you to host, no API key for the converter, and no infrastructure to keep alive.

The three pieces that landed GA together fit the workflow cleanly:

• Skills API: a simpler API for uploading and versioning your own skills. Attach a skill to any request via container.skills; Claude loads the folder only when the task calls for it.
• Files API: automatic file expiration, 5x higher rate limits, and 1 TB of storage per organization. Upload a Markdown draft once, reference it by file_id in later requests instead of re-sending it.
• Computer use: the updated tool takes several actions per turn instead of one per model call. The new browser use tool reads the structure of the page and targets a specific field rather than a screen position, which makes it reliable for agents that paste into LinkedIn, X, Medium, or Notion.

Box is already shipping this pattern. Matthew Midson, Managing Director of Banking at Box, described the production shape plainly: "The Skills API gave us a straightforward way to build specialized document creation into Box Agent. For a bank, a skill captures the firm's credit methodology and approved memo format; Box Agent applies it to the financial statements and deal documents already in Box and produces a source-grounded credit memo for analyst review." Same shape, different vertical: the skill holds the firm's formatting rules, the agent holds the working draft, the Files API holds the source documents.

Why md2rich belongs inside the skill, not behind a tool call

The other obvious shape is a tool call. The Claude agent decides it needs rich text, calls md2rich.com as an HTTP tool, sends the Markdown, gets the rich text back, and pastes it into the target platform. That works, but it has three costs the skill shape avoids.

First, a tool call exposes the Markdown to a public converter. The browser-side md2rich at md2rich.com never uploads anything, but a tool-call version would ship the Markdown over the network to a backend. That changes the privacy posture for anyone using the converter with drafts that are not yet public.

Second, the tool call adds an API key. Every tool call needs credentials, every credential needs rotation, and every rotation needs wiring into the agent's runtime. A skill runs inside Claude's own code execution sandbox, so the converter itself has no separate API key, no rotation, no separate rate limit to monitor.

Third, the rich text comes back as a structured response inside the same agent loop. The agent can iterate on it, hand it to another tool, or splice it into a larger workflow without buffering it through external state. The skill returns rich text the agent can act on; the tool call returns rich text the agent has to manage as an external resource.

A skill is the right shape for a stateless, deterministic, well-defined converter like Markdown to rich text. Tools are right for stateful, network-dependent, externally arbitrated actions. md2rich is the former.

The folder you actually upload

The Skills API takes a folder. Here is what an md2rich skill folder looks like in practice. It is small, versioned, and runs the same Markdown-to-rich-text pipeline the browser version runs, just inside Claude's sandbox instead of a browser tab.

SKILL.md. A short description of when the agent should load the skill, the inputs the converter expects, and the outputs it returns. The agent reads this before deciding to call the skill, so it has to be specific about the trigger ("convert Markdown to rich text for LinkedIn, X Articles, Medium, Notion"), the format it accepts (CommonMark plus GFM tables), and the format it returns (HTML plus a parallel Markdown comment block for accessibility).

scripts/convert.js. The Node script that does the actual conversion. The core of md2rich is the DOM-to-rich-text pipeline: parse the Markdown, build a DOM tree, serialize it as both clean HTML and a clipboard-ready rich text payload. The skill version runs the same script in the sandbox, with the same library choices, and writes the result to a file the agent can read back.

scripts/convert.py. A Python mirror for agents that prefer Python in their sandbox. Same input shape, same output shape, same library choices as the browser pipeline. The two scripts give the agent a language choice without changing the contract.

README.md. Version notes, the supported input dialect (CommonMark + GFM tables, fenced code, footnotes, task lists), the supported output targets (LinkedIn, X Articles, Medium, Notion), and the breaking-change policy. The README is what the agent reads when the version it has loaded is older than the latest and it is wondering whether to reload.

The folder is uploaded with the Skills API and versioned. A request references the skill through container.skills on the Messages API. When the agent decides the task needs rich text, Claude loads the folder, runs the right script in the sandbox, and returns the rich text as part of its response. The end result is a Skills API endpoint for md2rich that the agent can call without ever leaving Claude's run.

A worked example: shipping a thought-leadership draft

The cleanest demonstration is a single agent loop that takes a polished Markdown draft from the Files API, converts it to rich text with the md2rich skill, and hands the result to LinkedIn.

Step 1. Upload the draft once. Push the polished Markdown draft to the Files API. You get back a file_id you can reference in every later request. The Files API gives 1 TB of storage per organization and automatic file expiration, so the draft stays around exactly as long as the publishing window needs.

Step 2. Attach the md2rich skill. On the Messages API request, attach the md2rich skill through container.skills. Reference the draft through its file_id. Tell the agent what the publish target is.

Step 3. The agent runs the conversion in the sandbox. Claude decides the task needs rich text, loads the md2rich skill folder, runs scripts/convert.js on the file_id, and produces a clean rich text payload. The conversion happens inside the sandbox, the Markdown never leaves Claude's run, and the rich text comes back as a structured response the agent can act on.

Step 4. Hand the rich text to the LinkedIn connector. The agent's LinkedIn connector takes the rich text payload, opens the post composer, and pastes the formatted version. The paste keeps the headings, bold, italics, lists, tables, and code blocks you wrote, because the conversion produced real rich text, not a Markdown image or a copy that strips formatting.

Step 5. Verify and write back. The computer use tool, with the new browser use capability, can read the structure of the LinkedIn composer, confirm the right fields are filled, and let the agent post. The Files API can write the confirmation back as a new file so the same brain that holds the source-of-truth drafts also holds the shipping record.

The interesting part is what the agent does not have to do. It does not maintain a separate md2rich.com API key. It does not chain through an HTTP tool call. It does not splice the rich text back into its working state. The skill is part of the loop, the conversion is reproducible, and the rich text comes out in the shape the next step needs.

Where this fits against the converter in the browser

The Skills API version does not replace the browser version at md2rich.com. They do different jobs for different people.

The browser version. A person opens md2rich.com, pastes Markdown, copies rich text. There is no account, no upload, no server round-trip. The conversion runs in the browser tab on the person's machine. That is the right shape for a person drafting a post by hand, an editor reviewing a draft, or a developer pasting into a platform that does not have a Claude connector.

The Skills API version. A Claude agent decides it needs rich text, loads the md2rich skill folder, runs the conversion in the sandbox, and uses the result inside its own loop. The skill runs on Anthropic's infrastructure, the conversion is part of the agent's reasoning, and there is nothing for the agent's user to host. That is the right shape for automated publishing workflows, agent-driven content pipelines, and any team that already has Claude in its toolchain.

The two versions share the same conversion logic. The browser version is the reference implementation; the sandbox version is the same script running in a different process. If the script changes in the skill folder, the same change applies to both, because the conversion rules are the conversion rules regardless of where they run.

What ships with the Skills API GA on August 20, 2026

The full announcement is on the Anthropic blog at claude.com/blog/computer-use-skills-api-files-api. The verified facts worth keeping in mind for any team shipping a skill in 2026:

• General availability. The Skills API, the Files API, the updated computer use tool, and the new browser use tool are generally available on the Claude Platform today. The Skills API and the Files API are also available through Microsoft Foundry. The updated computer use and browser use tools are coming soon to Google Cloud's Vertex AI. Existing beta integrations keep working while you migrate.
• No hosting required. Skills run in Claude's code execution sandbox. There is nothing for the publisher to host and no separate API key for the converter.
• Files API limits. 1 TB of storage per organization, automatic file expiration, 5x higher rate limits.
• Computer use, multi-action turns. The updated tool takes several actions per turn rather than one per model call. Tasks finish in fewer calls and less time. Asteroid reported its longest claims workflow went from 32 minutes to 13, with cost per task down about 30% and completion at 100%.
• HIPAA eligibility. Computer use is eligible for HIPAA-regulated workloads under Anthropic's BAA, which matters for any team publishing in healthcare, insurance, or financial services.
• Documentation. The Skills API reference is at platform.claude.com/docs/en/agents-and-tools/agent-skills/overview, with companion docs for the Files API and the updated computer use and browser use tools.

Try the pattern in your own agent loop

Start by reading the Skills API overview in the docs. Pick a converter, formatter, or template that is currently a tool call in your agent loop and ask whether it could be a skill. If the answer is yes, package the converter as a folder, upload it with the Skills API, and reference it through container.skills on the Messages API. The sandbox runs the code, the agent gets a structured response, and the loop is one tool-call shorter than it was.

For Markdown publishers, the md2rich shape is the same pattern: a stateless converter that turns well-formed input into well-formed output. The browser version lives at md2rich.com for people who run the conversion themselves. The Skills API version belongs in any agent loop that ships Markdown to LinkedIn, X Articles, Medium, or Notion without exposing the draft to a third-party converter or carrying a separate API key.

Filed under: md2rich Blog. Written by the md2rich team (about.me/jasonxmai).