“You Mentioned No MCP!” | Earendil

If you went to pi.dev prior to now, you discovered a proud declaration that Pi does
not assist MCP. If you hearken to podcasts the place we talked about Pi, you’ll
have discovered a couple of dismissive assertion about MCP from us. Including a
post by Mario about
it. And
but, if you happen to improve to Pi one can find MCP is now a supported piece of
performance. What occurred?

Things Change

The very first thing to recollect is that the world is not
static.
We have been listening to MCP during the last 12 months and the MCP of in the present day is
not the MCP of yesteryear. That alone wouldn’t be a lot of a purpose to place it
into the core, nonetheless. As you understand, Pi has an incredible ecosystem of extensions,
certainly MCP may have been an extension? Maybe even an Earendil endorsed
extension. And sure you’re certainly appropriate in that MCP may have been an
extension, as it was. That MCP
is now a part of the core is a results of us placing our heads collectively and
rethinking it.

What Exactly Changed?

The purpose we introduced MCP into the core isn’t just about how MCP has modified,
but additionally as a result of we discovered that the modifications it will require had been usually
helpful. For instance, the modifications we’ve made to MCP additionally allow the usage of Jev
extra simply inside Pi. Ultimately what Pi wants is kind of much like what MCP
wants: a sandbox to play with within the type of an interpreter.

While quite a lot of issues have improved about MCP, fairly a number of haven’t. The greatest
challenge with MCP continues to be that it’s laborious to compose. Even with codemode,
which is only a neat little sandbox to permit composing of device calls, MCP
doesn’t totally ship on this. But that at this level is much less the issue of MCP
however the MCP servers on the market and completely different approaches of harnesses to work with
them.

Many MCP servers are nonetheless constructed for harnesses that simply dump instruments into the
context and are attempting to optimize on their aspect for token effectivity by
returning textual content. The approach we like to consider MCP at this level is that it
must be a lot nearer to OpenAPI with clever device discovery. That means
instruments ought to return structured information and instruments must be discoverable by their
documentation and outline.

The purpose CLIs are so purposeful is that the agent and mannequin simply wire stuff
along with environment friendly bashisms. But there isn’t a elementary purpose why you
can’t try this with MCP both. MCP in Pi is simply constructed on exposing these instruments
to a JavaScript sandbox like different harnesses like Codex do too.

MCP in a Modern LLM

This will elevate the query why we didn’t simply do Codemode with out MCP. Part of
the reply to this has to do with how instruments are expressed in Pi in the present day. We did a
lot of labor in current months to permit Pi to make sense with new fashions that
enable deferred device loading, mid-conversation system messages and reasoning
degree modifications. However we didn’t but improve our device loadout to higher scale
to those new capabilities.

In a Codemode globe one must resolve if the device is offered to the LLM or
solely the codemode a part of the LLM. A standard MCP extension doesn’t have sufficient
metadata obtainable from Pi’s device loadout to make that have work nicely. So
we wanted to make sure that instruments may be configured to simply be deferred or be a
Codemode particular factor.

And whereas we may have simply wired up the metadata to allow higher MCP
extensions, we additionally suppose that MCP with Codemode solves fairly a number of of the
points that it historically had. We consider one of the simplest ways to positively
affect one thing is to embrace it. And whereas we expect that trendy MCP is in a
a lot better spot than MCP ever was, the servers and patterns nonetheless go away room
for enchancment. So we wish to be a part of that dialog and assist form it to
work nicely in small harnesses as a substitute of standing on the sidelines and simply
watching.

What Is Codemode?

Now we talked a lot about Codemode, it is perhaps price explaining what that
even is. When a harness executes instruments, for probably the most half it has two sides: it
can do it the place bash runs, or it might probably do it the place the harness agent loop runs.
The belief degree on either side may be very completely different. The harness loop very often
runs in an atmosphere that’s trusted, whereas the instruments it executes typically run
inside a sandbox that’s not actually all that trusted.

Codemode is particular in that it runs the place the harness runs. It’s finest understood
as a mechanism to orchestrate and coordinate device calls. It’s a sandbox that
permits an agent to challenge these device calls in a approach that provides it extra
flexibility about by which order it ought to do it, and it permits it to make use of
JavaScript to mix them collectively. Because Codemode additionally runs on the harness
aspect, its state can also be maintained as a part of the session transcript as a substitute of
the file system.

Now in concept any language may do, however JavaScript is kind of engaging as small
variations of JavaScript may be shipped as WASM binaries and permit cheap
ranges of safety.

In Pi, Codemode is routinely loaded when MCP is configured, or it may be
added to the configuration as a default device. Just ask pi to reconfigure itself
to allow codemode! You can then use it for fairly fascinating issues, not simply
MCP. For occasion when you find yourself logged in with a supplier that gives “Jev” you
can do issues like this:

Use typesafe/jev by way of codemode to seek out the 20 most annoyed commenters on our challenge tracker

And it is going to cleverly mix issues just like the Linear MCP and Jev to try this
evaluation, proper from inside Pi, with out losing any context in any respect.

> Use typesafe/jev by way of codemode to seek out probably the most annoyed individuals on our challenge tracker

I'll pull the open points from Linear and let Jev price the tone of every thread, 4 at a time.

codemode
const { points } = await instruments.mcp__linear__list_issues({
  staff: "Pi", state: "open", restrict: 250,
});
const jev = await fashions.getModelOfType(
  "classifier", "cloudflare-workers-ai", "typesafe/jev",
);
const questions = {
  frustration: {
    kind: "alternative",
    directions: "Judge ONLY the emotional tone of the individuals writing. " +
      "Ignore how extreme the bug is.",
    standards: {
      none: "Neutral, factual, or pleasant, even a couple of critical bug",
      delicate: "Explicit annoyance, impatience, or disappointment",
      excessive: "Clearly offended, exasperated, sarcastic, or fed up",
    },
  },
};

const outcomes = [];
let subsequent = 0;
async perform employee() {
  whereas (subsequent < points.size) {
    const challenge = points[next++];
    const { feedback } = await instruments.mcp__linear__list_comments({
      issueId: challenge.identifier,
    });
    const c = await fashions.classify(jev, { state: { ...challenge, feedback }, questions });
    outcomes.push({ id: challenge.identifier, title: challenge.title, ...c.solutions.frustration });
  }
}
await Promise.all([worker(), worker(), worker(), worker()]);
retailer("frustration", outcomes);

const rating = (r) => r.chances.delicate * 0.5 + r.chances.excessive;
const counts = {};
for (const r of outcomes) counts[r.choice] = (counts[r.choice] ?? 0) + 1;
const flagged = outcomes.filter((r) => r.alternative !== "none");
flagged.type((a, b) => rating(b) - rating(a));
return {
  whole: outcomes.size,
  counts,
  flagged: flagged.map((r) => `${r.id} ${r.title}`),
};

... (331 earlier calls)
✓ mcp__linear__list_comments {"issueId":"PI-4714"} 255ms
✓ mcp__linear__list_comments {"issueId":"PI-3200"} 354ms
✓ fashions.classify cloudflare-workers-ai/typesafe/jev 756ms
✓ fashions.classify cloudflare-workers-ai/typesafe/jev 750ms

{
  "whole": 167,
  "counts": {
    "none": 156,
    "delicate": 11
  },
  "flagged": [
    "PI-7740 TUI after /reload does not follows custom tool's re…",
    "PI-9566 context size defaults to 128k despite the real size…",
    "PI-10031 Pi sporadically stuck in "Working..." when thinking…",
    "PI-4714 [feature] /replace TUI command as a substitute of pi replace",
    "PI-5916 Support supplier extensions with mannequin aliases and…",
    "PI-7547 [Windows] [sink-thread] How do you utilize Pi on window…",
    "PI-6907 Add an Installation part to the README",
    "PI-6212 Proposal: Bedrock path ought to honor `compat.forceAd…",
    "PI-9932 before_agent_start: pressured system immediate retains device…",
    "PI-7730 High CPU utilization on Mac OS with lengthy session",
    "PI-6600 pi replace --extensions and npm scripts: npm 11.16.0…"
  ]
}

Most of the tracker is calm. Jev rated 156 of the 167 open points as impartial, 11
as mildly annoyed and none as extremely annoyed.

The clearest circumstances:

- PI-6907 no set up part within the README (“It's irritating”) - PI-10031
Pi will get caught on “Working...” after urgent Esc throughout pondering - PI-4714 a
/replace command request (“a ache within the butt”) - PI-7730 excessive CPU utilization on macOS
in lengthy classes

The per-issue verdicts are saved in codemode below frustration, so I can dig
into any of them with out fetching the problems once more.

We can have extra to say about issues like Jev and Codemode later, however we hope
this put up serves for instance of how we proceed to adapt and replace Pi
thoughtfully because the globe continues to evolve.