Two New Integrations: Meta Muse and TypeSafe AI

September has been a busy month at the top of the agent stack. Meta launched Muse, a personal AI agent that books travel, fills in forms and acts on your accounts. TypeSafe AI shipped Jev, a model that does not write prose at all and instead returns typed decisions with calibrated probabilities. Different products, same direction of travel: agents are moving from suggesting things to doing them.

Both are now Vorim integrations, in the TypeScript and Python SDKs from version 3.21.0.

Meta Muse: the builder's side of the audit trail

Muse itself has sensible consumer guardrails. Meta says it checks with the person before sensitive actions like sending an email or making a purchase, lets people choose whether it can read mail or also send on their behalf, and gives every user an audit trail of what it has done and plans to do.

That covers the person using Muse. It does not cover you, the builder, when your own agent runs on Muse Spark and calls your tools. There the questions are the familiar ones. Which agent made that call? Was it allowed to? Can you prove it to an examiner six months later without asking Meta for logs?

Under Muse sits Muse Spark, which Meta exposes to developers through the Meta Model API at api.meta.ai. That endpoint speaks the OpenAI Chat Completions shape, tools and tool_calls included, so the same Vorim registry that gates OpenAI, Grok and OpenRouter works here unchanged. Point an OpenAI client at Meta's base URL, register your tools with the permission each one needs, and every custom tool call is permission-checked before it runs and signed after.

import OpenAI from "openai";
import createVorim from "@vorim/sdk";
import {
  VorimToolRegistry, runMuseAgentLoop, MUSE_BASE_URL,
} from "@vorim/sdk/integrations/muse";

const vorim = createVorim({ apiKey: "agid_sk_live_..." });

// The Meta Model API speaks OpenAI Chat Completions.
const muse = new OpenAI({
  apiKey: process.env.MODEL_API_KEY,
  baseURL: MUSE_BASE_URL,
});

const registry = new VorimToolRegistry({ vorim, agentId: "agid_abc123" });
registry.add({
  name: "book_travel",
  description: "Book a flight for the customer",
  parameters: { /* ... */ },
  execute: async (args) => bookFlight(args),
  permission: "agent:transact",   // checked + signed before it runs
});

const answer = await runMuseAgentLoop({
  vorim, agentId: "agid_abc123", muse, registry,
  userMessage: "Book the Tuesday flight to Lisbon",
  model: "muse-spark-1.3",
  parallelToolCalls: false,   // one gated action per turn
});

Two Meta-specific details are handled for you. Meta defaults parallel_tool_calls to true; pass false and the model requests at most one tool call per turn, so each gated action is decided in sequence rather than in a batch. And tool_choice is never sent, because Meta accepts only "auto" and returns a 400 for anything else.

One honest limit, the same one that applies to every model-API integration we ship. Vorim gates and signs the custom function tools you define and execute. Anything Muse does on Meta's own side, its browser and its built-in connectors, never passes through your executor, so it is not Vorim-attestable. If an action has to be provable, keep it in a custom tool you run.

TypeSafe AI: when the decision itself is the agent action

Jev is a different kind of thing. TypeSafe calls it a System One model, and it does not generate text. You hand it a state, a support ticket or a transaction or a record, and a map of typed questions. It returns typed answers with calibrated probabilities, in roughly 100 milliseconds. A noul question returns a probability between 0 and 1. A choice returns the selected option, the probabilities across all options and a confidence. A score returns a weighted value against a rubric, with its own confidence.

Because it is fast and cheap, teams put it inside agent control flow rather than beside it. Route this payout. Flag this claim. Decide whether this step needs a human. Which makes each Jev call an agent decision with consequences, and in a regulated setting a decision with consequences needs three things to be true. The agent that asked was allowed to ask. The decision is attributable to that specific agent. And the confidence behind it is on the record, not lost in a branch.

The integration does all three. Before the call it checks the asking agent holds the scope, and optionally clears a trust floor. After the call it turns Jev's calibrated confidence into a policy input: set a minimum and any answer below it comes back marked not actionable, so your code escalates instead of branching on a coin flip. Then it signs one audit event carrying the model version, the question ids, every typed answer, its confidence, and SHA-256 digests of the state and the answers.

import createVorim from "@vorim/sdk";
import { TypeSafeClient, choice, noul } from "@typesafe-ai/sdk";
import { createVorimTypeSafe } from "@vorim/sdk/integrations/typesafe";

const vorim = createVorim({ apiKey: "agid_sk_live_..." });

const jev = createVorimTypeSafe(vorim, {
  agentId: "agid_abc123",
  client: new TypeSafeClient(),   // reads TYPESAFE_API_KEY
  minConfidence: 0.8,             // below this, actionable = false
});

const d = await jev.decide({
  purpose: "route-refund",
  resource: "TCK-4821",
  state: { ticket: "I was charged twice. Please fix this ASAP." },
  questions: {
    category: choice("What is this ticket about?", { billing: null, technical: null, other: null }),
    urgent: noul("Does this convey urgency?"),
  },
});

if (d.authorized && d.actionable) {
  route(d.answers.category.choice);   // confident enough to act on
} else {
  escalate(d.reason);                 // low confidence or denied: a human decides
}

Note what is on the record and what is not. The digests are there, so anyone can confirm later that this decision was made about that exact state and produced those exact answers. The raw state is not, because a support ticket or a claim is the customer's data, not ours.

The confidence floor is the part we think matters most. A calibrated probability is only useful if something acts on it. Without a floor, a 51 percent choice and a 99 percent choice branch identically and nobody finds out until an auditor asks why a refund was routed the way it was. With one, the uncertain cases become escalations, and the record shows which is which.

Getting them

Both ship in @vorim/sdk 3.21.0 on npm and vorim 3.21.0 on PyPI, with the same API in each language. Import @vorim/sdk/integrations/muse or @vorim/sdk/integrations/typesafe in TypeScript, or vorim.integrations.muse and vorim.integrations.typesafe in Python.

The Muse connector sits on the same tool registry as the others, so if you already run an agent on OpenAI or OpenRouter the change is the base URL and the model id. The TypeSafe connector works with the official @typesafe-ai/sdk client or, if you would rather not add the dependency, a built-in client that calls the REST endpoint directly.

See every integration →

Questions, we read every email at team@vorim.ai.