You use an internal tool at work that your team built three years ago. It has a REST API, a small database, and a half-finished JavaScript SDK. You have wanted to ask your AI "hey, pull the last week of incidents from that tool" for months. You have never done it, because the glue code to let the AI talk to your tool sits somewhere between "tedious" and "actually a research project." This post is about the afternoon that makes it routine.

The missing integration problem

Every developer who uses AI at work has a shortlist of internal or niche tools the AI cannot reach. A small team's Airtable base. A self-hosted monitoring dashboard. A weather station on your roof. A piece of manufacturing equipment with a Modbus interface. The AI can write the integration; the AI cannot install itself into your network and start talking to the thing. Someone has to build the bridge.

Before MCP, that bridge meant learning one specific platform's plugin API, committing to its distribution model, and rewriting the work when you wanted a second platform supported. Now the bridge is an MCP server. One server, any platform that speaks the protocol.

The afternoon arc

The five steps:

1. Scaffold (five minutes).

$ npm run create-integration
? What is your integration called? my-company-monitor
? Which AI should it serve? [bundle]
? Generate a panel? [yes]
✔ Created bundles/my-company-monitor/

You get a manifest, a Docker Compose file (optional), a scaffolded MCP server, and a panel stub.

2. Wire one tool (thirty minutes).

Open bundles/my-company-monitor/server/index.js. The template has one example tool. Rename it, point it at your API endpoint, return a JSON response. Three lines of real logic.

server.tool(
  "list_incidents",
  "List incidents from the internal monitor",
  { since: z.string().optional() },
  async ({ since }) => {
    const data = await fetch(`${API}/incidents?since=${since}`);
    return { content: [{ type: "text", text: JSON.stringify(await data.json()) }] };
  }
);

3. Ship a panel (ninety minutes).

The panel stub gives you a page in the Nest sidebar. Swap the placeholder content for a small HTML table driven by the same API your MCP tool calls. Design tokens and shared components make this faster than writing your own CSS. The Nest handles auth, routing, and the sidebar position.

4. Register (two minutes).

Add one line to registry/add-ons.json with your bundle's id, name, description, category, and icon. The Extensions page picks it up automatically.

5. Test with your AI (thirty minutes).

Install your own bundle. Ask your AI to pull the last week of incidents. Watch the tool call land in your Nest log. Watch the summary come back. The glue code is done. The AI does the work.

Total: under three hours including coffee.

What Crow handles for you

Crow handles the web server, the auth layer, and the protocol for you. Those are solved. Your afternoon is spent on the thing that is actually interesting: the shape of your integration.

The gateway handles HTTP plus MCP transport, session management, OAuth. The Crow's Nest handles the panel mounting, sidebar navigation, and session cookies. The add-on registry handles discovery and installation. You write the domain logic.

Tradeoffs, honestly

The first bundle takes longer than the second. Expect four to six hours for your first one while you learn the shape. Subsequent bundles land in two to three hours once you know where the files go.

The panel piece is optional. If your integration is AI-only (no human-facing UI needed), skip the panel stub and save ninety minutes.

Long-term, maintain your bundle as you would any small service. External APIs change. The MCP spec evolves. Plan on an hour per quarter for upkeep, or less if you pin dependencies and the target API is stable.

Finally: contributing. If your bundle is useful to others, submit it to the public registry. The PR template walks through the checklist. Or keep it private and let your team use it on your own gateway.

Start here

Pick one tool you wish your AI could talk to. Ten seconds. Now run npm run create-integration and build the bridge: getting started with Crow.

This is the last post in the series. The full set covers memory, federation, family, consulting, compliance, classrooms, protocol, and bundles. The next move is yours.