> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rkat.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# WASM runtime

> Browser deployment with the meerkat-web-runtime embedded surface.

The WASM runtime compiles the full Meerkat agent stack to wasm32 for browser deployment. It routes through the same `AgentFactory::build_agent()` pipeline as all other surfaces.

<Note>
  This page is intentionally browser/WASM-specific rather than a cross-surface tabbed page. Use [Examples: Mobpack](/examples/mobpack) first if you want the packaging/deployment path that usually leads into browser delivery.
</Note>

## Build the WASM bundle

<Tabs>
  <Tab title="CLI">
    Build a web bundle from a `.mobpack` artifact:

    ```bash theme={null}
    rkat mob web build ./dist/my-mob.mobpack -o ./dist/web-bundle
    ```
  </Tab>

  <Tab title="Manual (wasm-pack)">
    Build the WASM package directly with wasm-pack:

    ```bash theme={null}
    RUSTFLAGS='--cfg getrandom_backend="wasm_js"' \
      wasm-pack build meerkat-web-runtime --target web --out-dir pkg
    ```
  </Tab>
</Tabs>

## Initialize runtime

Use init-time credentials and provider base URLs to seed the browser runtime's
realm config. The `@rkat/web` `RuntimeConfig` still exposes `apiKey`/`baseUrl`
compatibility fields for older callers, but the current runtime contract is
provider-specific: `anthropicApiKey`, `openaiApiKey`, `geminiApiKey`, and the
matching provider base URL fields. `SessionConfig` does not accept per-session
`apiKey` or `baseUrl`.

```typescript theme={null}
import { MeerkatRuntime } from "@rkat/web";
import * as wasm from "@rkat/web/wasm/meerkat_web_runtime.js";

const runtime = await MeerkatRuntime.initFromMobpack(wasm, mobpackBytes, {
  anthropicApiKey: "sk-ant-...",
  model: "claude-sonnet-4-6",
});
```

For proxy deployments, pass a provider-specific dummy key and base URL. The
proxy injects the real server-side credential.

```typescript theme={null}
const runtime = await MeerkatRuntime.init(wasm, {
  anthropicApiKey: "proxy",
  anthropicBaseUrl: "http://localhost:3100/anthropic",
  model: "claude-sonnet-4-6",
});
```

## Create session and run turn

```typescript theme={null}
const session = runtime.createSession({
  model: "claude-sonnet-4-6",
});

const result = await session.turn("Hello");
console.log(result.text);
```

For OAuth or host-owned cloud credentials, register an external auth resolver
and bind the session to a structural auth binding. The selected realm binding
must be configured to use the WASM external-resolver credential source.

```typescript theme={null}
import { registerExternalAuthResolver, withAuthBinding } from "@rkat/web";

registerExternalAuthResolver(wasm, async (authBinding) => {
  const token = await hostAuth.freshAccessToken(authBinding);
  return {
    kind: "inline_secret",
    secret: token.accessToken,
    metadata: { account_id: token.accountId },
    expires_at: token.expiresAt,
  };
});

const bound = runtime.createSession(withAuthBinding(
  { realm: "team-alpha", binding: "anthropic" },
  { model: "claude-sonnet-4-6" },
));
```

## Poll events

```typescript theme={null}
for (const event of session.pollEvents()) {
  if (event.type === "text_delta") {
    document.body.innerText += event.delta;
  }
}
```

## Mob lifecycle in browser

```typescript theme={null}
// Create mob from definition
const mob = await runtime.createMob({
  id: "research-team",
  orchestrator: { profile: "lead" },
  profiles: {
    lead: { model: "claude-sonnet-4-6" },
    worker: { model: "claude-sonnet-4-6" },
  },
});

// Spawn members
await mob.spawn([
  { profile: "lead", agent_identity: "lead-1" },
  { profile: "worker", agent_identity: "worker-1" },
]);

// Wire peers
await mob.wire("lead-1", "worker-1");

// Inspect runtime state
const members = await mob.listMembers();
const leadStatus = await mob.memberStatus("lead-1");
```

## Subscribe to member events

```typescript theme={null}
const sub = await mob.subscribeMemberEvents("lead-1");

for (const event of sub.poll()) {
  console.log(event.type, event);
}

sub.close();
```

## Cross-mob comms

Wire ambassadors across mobs for inter-faction communication. `MeerkatRuntime.wireCrossMob()` establishes trust between members in different mobs so they can exchange messages via the comms system.

```typescript theme={null}
// Wire ambassadors between two mobs
await runtime.wireCrossMob(
  northMob.mobId,
  "ambassador-north",
  southMob.mobId,
  "ambassador-south",
);

// Send work to a member through the canonical member path
await northMob
  .member("ambassador-north")
  .send("Send a message to the south faction proposing an alliance on the eastern front.");
```

<Note>
  Direct `comms_send` and `comms_peers` are reserved low-level placeholders rather
  than current wasm-bindgen exports or public `@rkat/web` wrapper methods.
  Inter-agent messaging happens through member-directed turn submission and the
  comms tools available to agents during their turns (`send_message`,
  `send_request`, `send_response`, and `peers`).
</Note>

## What is available on wasm32

| Category       | Available                                   | Not available                            |
| -------------- | ------------------------------------------- | ---------------------------------------- |
| **Agent loop** | Full agent state machine, streaming, budget | --                                       |
| **Providers**  | Anthropic, OpenAI, Gemini (browser fetch)   | --                                       |
| **Sessions**   | Ephemeral sessions                          | Persistent sessions (filesystem)         |
| **Mobs**       | Full orchestration, flows, lifecycle        | --                                       |
| **Comms**      | In-process (`inproc`) transport             | TCP, UDS, network transports             |
| **Tools**      | Custom tools, tool dispatch                 | Shell tools, filesystem tools            |
| **Skills**     | Embedded skills, HTTP skills                | Filesystem skill sources                 |
| **Hooks**      | In-process hooks                            | Command hooks, filesystem hooks          |
| **Compaction** | Context compaction                          | --                                       |
| **Other**      | --                                          | MCP client, delegated work orchestration |

## Next step

* [Examples: Mobpack](/examples/mobpack) — the packaging/deployment path that often comes before browser delivery
* [Examples: Mobs](/examples/mobs) — the multi-agent runtime model behind many WASM demos