jev·agent
Get API access

Integration

Jev over MCP

Model Context Protocol is how an agent reaches a capability nobody wired in for it. Jev is an unusually good fit: a tool that costs a fraction of a cent and returns a calibrated probability is exactly the kind of thing an agent should be allowed to call freely.

Why this pairing is more than a wrapper

An agent's expensive habit is deliberating in tokens. It reasons about whether a claim holds, whether a candidate fits, whether content is safe — each of those is a paragraph of generated thought standing in for a judgement, and the paragraph costs real money and real seconds.

Handing the agent a decision tool changes the economics of its own reasoning. The judgement comes back as a number, in under a second, for a fraction of a cent, with a confidence attached — so the agent can also know when not to trust it. That last part is what an LLM asking itself cannot do honestly: verbalised confidence is not calibrated.

What TypeSafe ships

Official installable agent skills package (npx skills add typesafe-ai/skills) that teaches an agent the Jev workflow.

Worth understanding the distinction: a skill teaches an agent how to use the API it already has access to; an MCP server is the access. If your agent can already make HTTP calls with your key, the skills package may be all you need.

The community servers

jkudish/jev-mcp

Proof-of-concept MCP server putting Jev claim verification, content screening and candidate ranking behind standard MCP tools.

blakestone-x/jev-mcp

MCP server exposing Jev classify, score, check, match and screen as tools for any agent, with confidence on every answer.

dakdevs/decide-mcp

Configurable decision server with percentage scores and bias-profile routing on top of Jev.

gamesonrblx/Jevbridge

ACP and MCP adapter exposing Jev typed decisions to Codex, Claude, Grok and other LLMs.

AkashPriyadarshii/jev-seo

Agent-first SEO and GEO search radar, shipped as both a CLI and an MCP server powered by Jev.

The part worth getting right: tool shape

The servers above split into two philosophies, and it is the only decision that really matters if you build your own.

Verb tools

classify, score, check, match, screen. The agent picks a verb and fills in options. Discoverable, and the tool names alone tell the agent what the capability is for.

One generic tool

A single decide that takes a state and a question spec. Maximum flexibility, but the agent has to understand the primitives before it can use it at all.

Verb tools win in practice, for the same reason Jev's own option descriptions matter so much: the words are the interface. An agent choosing between screen and rank is making an easy decision; an agent composing a Score rubric from scratch is making a hard one.

Rolling your own

It is a small amount of code, and building it yourself means the tool descriptions match your domain rather than a generic one. The shape, in outline:

typescript
// One narrow tool beats one flexible tool. Name it after the decision,
// not after the model — the agent is choosing by the description.
server.tool(
  "screen_candidate",
  "Judge whether a candidate meets the role's hard requirements. " +
    "Returns a probability and a confidence, not a verdict.",
  { candidate: z.string(), requirements: z.string() },
  async ({ candidate, requirements }) => {
    const res = await jev.systemOne({
      model: "jev-latest",
      state: { candidate, requirements },
      questions: {
        meets_bar: {
          type: "noul",
          instructions: "Does the candidate meet every hard requirement listed?",
        },
      },
    });
    const { noul } = res.answers.meets_bar;
    // Hand back the number. Let the agent decide what to do at 0.6.
    return { content: [{ type: "text", text: JSON.stringify({ meets_bar: noul }) }] };
  },
);

Common questions

Is there an official Jev MCP server?

Not from TypeSafe. What TypeSafe does publish is an agent skills package, installable with npx skills add typesafe-ai/skills, that teaches an agent the Jev workflow. The MCP servers themselves are all community projects.

Why put Jev behind MCP rather than calling the API?

Because the caller is an agent rather than your code. MCP is how an agent discovers and invokes a capability it was not compiled against — so a Jev MCP server turns 'make a calibrated decision' into something Claude, Codex or any MCP client can reach for on its own.

Does an MCP server need my own API key?

Yes, every one of these is a thin wrapper over the hosted API. You supply a TypeSafe or gateway key; the server supplies the tool shape and the argument validation.