Your AI models, for every app you choose.

AI in apps is stuck between two bad options.

Either each app asks for your keys, or it ships its own model. BLAID is the third option: the apps you approve share the models you already have, on your terms.

How it works

1. 1

   Install BLAID and point it at your models

   It runs in the tray. Ollama on this computer is picked up on its own. Add LM Studio, llama.cpp or any OpenAI-compatible server by address, a model server on another PC, or OpenAI and Anthropic with a key that goes straight into your OS keychain.

   

2. 2

   An app asks; you approve it once

   The app names the roles it needs, like npc-dialogue, and what each one requires. BLAID pre-selects the best model that qualifies, greys out the rest with the reason (missing feature: tools), lists the tools the app's model may ask for, and says plainly if a choice would send prompts online.

   Pick a paid online model and BLAID shows its price, says the prompts will leave your computer, and pre-fills a budget for that app. The same approval then covers every route the app arrives by: its website, its desktop build, a new game world.

   

3. 3

   The app talks to your models, whatever pipe it has

   Here a Luanti mod with no network access streams the innkeeper's lines through files in its own world folder, and she hands over torches and bread with a tool call. Below, a web page reaches the same models through the extension.

   

   

Watch it end to end

50 seconds, two apps: a website asks for access through the extension and streams a reply, then a sandboxed game mod does the same with no network at all.

One service in the middle. Thin pieces around it.

BLAID owns every key, approval and model choice. Apps reach it by whichever route their platform allows; the messages are the same on all of them.

For developers: about ten lines, and no key handling

Declare your roles and tools once. Show whatever state you get. Ask for access from a button. Then prompt, stream, run multi-turn sessions and tool calls like any Open Responses client.

import { Bridge } from "@local-model-bridge/sdk";

const bridge = await Bridge.connect({
  app: { id: "com.example.tavern", name: "Tavern Tales" },
  roles: {
    "npc-dialogue": {
      description: "Speaks for the innkeeper",
      require: { features: ["tools"], minContextTokens: 8192, general: { min: "ref:gpt-4o-mini" } },
    },
  },
  tools: [{ name: "give_item", description: "Hands the player an item" }],
});

bridge.addEventListener("statechange", () => render(bridge.state, bridge.ui()));
if (bridge.state === "no_grant") await bridge.requestAccess(); // from a button

for await (const chunk of bridge.promptStreaming("Good evening!", { role: "npc-dialogue" })) {
  showText(chunk);
}

from local_model_bridge import Bridge

bridge = Bridge.connect({
    "app": {"id": "com.example.tavern", "name": "Tavern"},
    "roles": {"chat": {"description": "Talks to the player",
                       "require": {"features": ["tools"]}}},
})
print(bridge.state, bridge.ui().title)   # a detection state and the text to show

if bridge.state == "no_grant":
    bridge.request_access()              # opens the consent window, waits for the user

for chunk in bridge.prompt_streaming("Tell me about the inn."):
    print(chunk, end="", flush=True)

using LocalModelBridge;

using var bridge = await Bridge.ConnectAsync(manifest);
bridge.StateChanged += (_, e) => Render(e.State, bridge.Ui());

if (bridge.State == DetectionState.NoGrant)
    await bridge.RequestAccessAsync();          // opens the consent window

await foreach (var chunk in bridge.PromptStreaming("Tell me about the inn.",
                   new GenerationOptions { Role = "npc-dialogue" }))
    Console.Write(chunk);

// Unity: add a BridgeBehaviour; callbacks arrive on the main thread.

-- Luanti: no sockets, no HTTP, no settings changed. Just files in the world folder.
local B = dofile(core.get_modpath("mymod") .. "/bridge.lua")
local client = B.new({dir = core.get_worldpath() .. "/bridge",
                      manifest = MY_MANIFEST, deps = B.luanti_deps()})
client:start()
core.register_globalstep(function(dtime) client:step(dtime) end)

client:respond({model = "role:npc", input = "Hello!", tools = TOOLS,
  on_text = function(delta) say(delta) end,
  on_tool = function(name, args) return give(args.item) end})

Package names are from 1.0.0-rc.1 and change with the rename to BLAID; nothing is on npm, PyPI or NuGet yet.

Your UI is a switch statement

Detection always returns exactly one of seven states, and every SDK ships ready-made wording for each, so “BLAID isn't installed” and “this site isn't enabled” never look like errors.

1. not_installedNo BLAID on this machineOffer the download
2. extension_missingWeb: no extensionInstall BLAID and its extension
3. not_enabledWeb: site not enabledEnable this site from the toolbar
4. not_runningInstalled, not answeringStart BLAID
5. no_grantRunning, not approvedAsk for access (opens consent)
6. no_modelApproved, no model fitsSay what the role needs
7. readyGood to goPrompt away

Ask for capability, not a model name

A role says what it needs: features (tools, vision, structured_output), context length, and a capability floor. The floor is a reference model (ref:gpt-4o-mini, “at least this good”) or a number on the Epoch Capabilities Index, an open scale where Claude 3.5 Sonnet is 130 and GPT-5 is 150.

match ranks the user's models against it and explains every miss (context 4096 < 8192), so your app or the consent screen can say exactly what to install. Scores come from a signed catalog that updates without a BLAID release; users can enter their own for models it doesn't know.

You stay in charge after you say yes

Approval is once per app, never forever. Remap a role, cap spending, turn tool use off, block one route or revoke the app entirely; it finds out at once.

Per-app settingsBudgetsActivityProviders

Built for a service that holds keys that cost money

The service is Rust, with a public threat model and a 22-item security self-review. What it can't do: protect you from malware already running as you, or prove a desktop app's identity (it shows the program's path instead). An outside security review comes before 1.0.

Standards first; new parts only where none exist

BLAID invents only what no standard covers: capability descriptors, requirement matching, roles, grants and detection states.

Open Responses

Requests, streaming and tool calls use the multi-vendor standard built on the OpenAI Responses API, pinned to 2026-04-24.

OpenAPI 3.1 + JSON Schema

The /bridge/v1 contract is frozen; CI rejects anything but additive changes. SDK types are generated from it.

Chrome Prompt API shape

prompt(), promptStreaming(), create(): web developers reuse what they already know.

Native Messaging

How pages reach BLAID in Chrome and Firefox, without CORS or localhost permission prompts.

Server-Sent Events

Streams and change events, resumable with Last-Event-ID.

OS keychains

macOS Keychain, Windows Credential Manager, Linux Secret Service. No keys in config files.

Ed25519 signatures

The model-score catalog is signed and checked against a key compiled into BLAID.

Epoch Capabilities Index

One open-ended capability scale, so a requirement written today means the same in three years.

Where it stands: 1.0.0-rc.1

All five v1 milestones are built and merged, and the API is frozen. What's left before 1.0 needs people and machines more than code.

Questions

What does BLAID stand for?

Bridge for Local AI Dispatch. It sits between your apps and your models and routes each request to the model you chose. Screenshots on this page still show its working name, Local Model Bridge.

Do my prompts leave my computer?

Only when you map a role to an online provider such as OpenAI or Anthropic, and the consent screen says so in plain words. Local and LAN models never leave your network, and BLAID itself sends no telemetry.

Why not let apps call Ollama directly?

Ollama has no idea which app is asking, can't hold keys for paid providers, and browsers increasingly block pages from reaching it. BLAID adds consent, roles, budgets and one API over Ollama and everything else.

Does it download models or need a GPU?

No to both. BLAID uses whatever you already run (Ollama, LM Studio, llama.cpp) or the online providers you add a key for. It never pulls models in v1.

How does an app pick a model it has never heard of?

It doesn't. It states what a role needs: features like tools or vision, context length, and a capability floor such as "at least as good as gpt-4o-mini". BLAID ranks your models against that and you confirm.

Which games can use it?

Anything that can make an HTTP call: Unity, Godot, Unreal, Minecraft Java, SMAPI, SKSE. Sandboxes that only allow files, like Luanti, use the file transport. Roblox and WoW add-ons are out of reach.

Can a model run tools on my computer?

Not in v1. Tools are defined by the app and run inside the app ("give the player a torch"). BLAID only lets a model call tools the app declared and you approved, and you can switch tool use off per app.

Is it open source? When can I install it?

It is Apache-2.0 licensed and at 1.0.0-rc.1: every v1 milestone is built and the API is frozen. Join the list to hear when signed installers are ready to download.