One Accountability Layer Across Every Model: Vorim and OpenRouter

Most teams building agents stopped picking one model a while ago. You use Claude for the hard reasoning, a cheaper model for the routine calls, and a fallback for when your first choice is rate-limited at 2am. Managing that by hand — a different SDK and key per provider — gets old fast.

OpenRouter fixes the plumbing. It's one OpenAI-compatible endpoint that routes across 500+ models from 60+ providers, with automatic fallbacks and a single key. Point your client at it, name a model like anthropic/claude-fable-5, and swap that string whenever you want. The request shape, tools included, stays the same.

Which is great for capability and cost. It also quietly widens a gap.

The gap

When the model underneath your agent keeps changing, so does the thing you'd point to if someone asked what happened. One request ran on Claude, the next on GPT, the one after that fell through to a third provider you didn't consciously choose. The agent still touched your data and called your tools throughout. But "which model did it" is no longer a stable answer, and in a regulated setting "the router picked one" is not a satisfying one either.

The accountability question doesn't care which model ran. It cares which agent acted, whether it was allowed to, and whether you can prove it afterwards. That has to hold no matter what OpenRouter routes to.

What we built

Today Vorim has a first-class OpenRouter integration, in both the TypeScript and Python SDKs.

Because OpenRouter speaks the OpenAI tool-calling format, it slots into the same gate-and-sign engine we already use for OpenAI, Claude, and Grok. You wrap the custom tools your agent can call. Before any of them runs, Vorim checks the agent has permission for that action; after it runs, Vorim signs a tamper-evident record of what happened. This is true on every turn of the loop, whichever model OpenRouter chose for that turn.

It handles OpenRouter's own routing too. Pass a fallback list of models and we forward it, so OpenRouter walks your preferred order on error, while Vorim keeps signing every tool call across all of them. The model can change mid-run; the accountability layer doesn't.

Here's the shape of it in TypeScript:

import OpenAI from "openai";
import createVorim from "@vorim/sdk";
import {
  VorimToolRegistry, runOpenRouterAgentLoop, OPENROUTER_BASE_URL,
} from "@vorim/sdk/integrations/openrouter";

const vorim = createVorim({ apiKey: "agid_sk_live_..." });
const openrouter = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,
  baseURL: OPENROUTER_BASE_URL,
});

const registry = new VorimToolRegistry({ vorim, agentId: "agid_abc123" });
registry.add({
  name: "refund_order",
  description: "Issue a refund",
  parameters: { /* ... */ },
  execute: async (args) => issueRefund(args),
  permission: "agent:transact",   // checked + signed before it runs
});

const answer = await runOpenRouterAgentLoop({
  vorim, agentId: "agid_abc123", openrouter, registry,
  userMessage: "Refund order 4821",
  model: "anthropic/claude-fable-5",
  models: ["anthropic/claude-fable-5", "openai/gpt-latest"], // fallback chain
});

The Python SDK mirrors it exactly: pip install vorim, then vorim.integrations.openrouter.

One honest limit

Vorim signs the custom tools you define and execute. If a model runs a provider-side built-in tool inside the upstream — web search, code execution, whatever the provider offers server-side — that runs outside your code and outside our gate, so it isn't attestable. The rule is simple: if you need an action on the record, keep it in a custom tool you execute. Everything through the loop above is covered.

The point

The industry is converging on a world where the model is a swappable component, chosen per request for cost, speed, or availability. That's the right direction. It just means the thing that stays constant can't be the model. It has to be the layer that proves what the agent did.

Route across every model you like. Keep one record you can stand behind.

If you're running agents through OpenRouter, or putting agents into regulated production and need to prove what they do, that's exactly what we build.

Book a demo →