---
title: "Mesher: a sandbox for AI agents that connect, build and use tools"
url: https://mesher.sh/
description: "Open-source Rust host that runs sandboxed WebAssembly connectors as MCP servers and CLI apps, with profiles, TOON output, cron schedules and workflows."
---

Open source · built for agents

# Give your agents tools, schedules and workflows.

Mesher is a small Rust host that runs sandboxed WebAssembly connectors as **MCP servers** and **CLI apps** at the same time. Every connector sits behind one MCP tool, the host keeps the credentials for each profile, results come back in token-saving TOON, and cron schedules and workflows come built in.

[Get started](https://mesher.sh/#install)

[View on GitHub](https://github.com/agentrq/mesher)

```text title="MCP your agent calls callTool"
# find a tool
gmail.searchTools 'unread' 10

# send as the work profile
gmail@work.tools sendEmail
  -b '{"to":"ada@example.com","subject":"Hi"}'

# run a workflow every weekday at 9
cron.tools schedule -b '{"connector":"digest",
  "tool":"startRun","schedule":"0 9 * * 1-5"}'

# get results in TOON (callTool arguments)
{"command":"gmail.tools listMessages","format":"toon"}
```

```sh
# find a tool
$ mesher gmail searchTools 'unread' 10

# send as the work profile
$ mesher gmail tools sendEmail --profile work \
    -b '{"to":"ada@example.com","subject":"Hi"}'

# run a workflow every weekday at 9
$ mesher cron tools schedule -b '{"connector":"digest",
    "tool":"startRun","schedule":"0 9 * * 1-5"}'

# get results in TOON
$ mesher gmail tools listMessages --format toon
```

One parser, one dispatcher: a command behaves the same for your agent and in your terminal.

## One tool. Every connector.

An agent shouldn't need hundreds of tool definitions in its context. Mesher exposes a single MCP tool, `callTool`, that takes a command line. The agent searches, reads help, and calls, the way you'd use a shell.

- **Small context.** Tools are found with `searchTools` and explained with `help`, so they don't all sit in the prompt.
- **MCP and CLI share one parser.** A command behaves the same from an agent and from your terminal, so you can test what the agent will do.
- **Both MCP revisions.** One endpoint serves 2026-07-28 and 2025-11-25. Each request is routed by the revision it uses.
- **Agents can manage it too.** The built-in `manage` connector installs, configures and removes connectors as tools.

```sh
$ mesher list
$ mesher math tools equation -b '{"expression":"x^2 - 3x + 2 = 0"}'
$ mesher time tools convert -b '{"time":"2026-10-07 09:00",
    "timeZone":"America/New_York","to":["Asia/Kolkata"]}'
$ mesher serve   # MCP at http://127.0.0.1:8080/mcp
```

## Connectors run in a sandbox, not on trust.

A connector is a `wasm32-wasip2` component with its manifest embedded in it. It gets no network of its own: the host makes each HTTP request for it, checks the request against an allowlist, and adds your credentials itself.

- **Allowlisted outbound HTTP.** A connector reaches only the hosts its manifest names. Everything else is refused.
- **Credentials the connector never sees.** OAuth 2.0 (PKCE, client credentials, refresh), API keys, bearer and query tokens are added by the host.
- **Encrypted at rest.** Each profile's secrets live in their own age-encrypted file.
- **Hot install.** Install, replace and remove connectors while the server runs: from a `.wasm` file, the GitHub catalog, or a remote MCP server's URL.

- **Remote MCP servers as connectors.** Install one by URL. Its OAuth metadata (RFC 9728, RFC 8414) is followed, and it registers its own client where the server allows (RFC 7591).
- **Limits per call.** Time and memory are capped for each call, and built-ins that need no network are given no hosts at all.
- **Trajectory.** Watch a profile's tool calls live in the web UI: who called, what was sent and answered, and how long it took.

## Work and personal, side by side.

A profile is a named set of connectors, each signed in to one account. Keep a work and a personal Gmail apart, and decide exactly what each MCP app may reach. Name the profile after an `@`, or leave it out to use `default`.

```text title="MCP once per connector"
# store Gmail's OAuth app; every profile shares it
manage.tools setInputs -b '{
  "connector": "gmail",
  "values": {
    "client_id": "1234.apps.googleusercontent.com"
  }
}'
```

```sh
# <connector>=<client id>; the secret is read
# from MESHER_<NAME>_CLIENT_SECRET
$ export MESHER_GMAIL_CLIENT_SECRET=…
$ mesher init --oauth-client \
    gmail=1234.apps.googleusercontent.com
```

```text title="MCP sign in each profile"
# sign each profile in to its own account
gmail@work.tools auth
gmail@personal.tools auth

# the same tool, a different inbox
gmail@work.tools listMessages -q maxResults=5
gmail@personal.tools auth status
gmail@work.tools auth logout
```

```sh
# sign each profile in: a browser opens
$ mesher gmail tools auth --profile work
$ mesher gmail tools auth --profile personal

# the same tool, a different inbox
$ mesher gmail tools listMessages --profile work \
    -q maxResults=5
$ mesher gmail tools auth status --profile personal
$ mesher gmail tools auth logout --profile work
```

- **One credential per profile.** Register an OAuth app once, then sign in once per account. From a shell, `tools auth` opens your browser and catches the answer on a one-shot loopback callback.
- **Least privilege per app.** Each profile opts into connectors, and can hide single tools, resources and prompts from the apps let into it.

- **Bundles.** Group connectors, like Gmail, Calendar and Drive as *Google*, and switch them on for a profile in one go.
- **Scoped automation.** Schedules and workflows run as their profile and reach only what it exposes.

## The same data in fewer tokens.

Results are JSON by default. Switch a profile, or a single call, to [TOON](https://github.com/toon-format/toon) and lists of records lose their repeated keys and quotes. Your agent reads the same data and spends less of its context on it.

```json
{"users":[
  {"id":1,"name":"Ada","role":"admin"},
  {"id":2,"name":"Bob","role":"member"},
  {"id":3,"name":"Cy","role":"member"}
]}
```

```toon
users[3]{id,name,role}:
  1,Ada,admin
  2,Bob,member
  3,Cy,member
```

- **Per profile or per call.** Set it on the profile's page, with `"format": "toon"` next to the command over MCP, or `--format toon` on the CLI.
- **Never breaks a call.** Only JSON text and JSON resources are rewritten. Anything that doesn't convert stays as it is.

- **Files untouched.** Images, audio and base64 files are never changed.
- **A host-wide default.** Set `MESHER_DEFAULT_FORMAT=toon` once. A profile's own choice still wins.

## Let agents put work on a schedule.

The built-in `cron` connector calls any tool of any connector on a schedule: check something every 15 minutes, post a report each weekday at 9. The server keeps the schedules and does the calling, so the agent doesn't have to stay running.

```text title="callTool"
cron.tools schedule -b '{"connector":"time","tool":"now",
  "schedule":"*/15 * * * *",
  "input":{"timeZone":"Europe/Berlin"}}'
cron.tools listSchedules -b '{"connector":"time"}'
cron.tools listRuns -b '{"status":"failed","limit":10}'
```

- **Standard cron.** Five fields or `@daily` and friends, in UTC or any IANA time zone, with daylight saving.
- **Runs as its profile.** A job can use only the tools and sign-ins that profile exposes.
- **Run history.** Every run's input, output and status (`succeeded`, `failed`, `skipped`) is kept for as long as you configure.
- **Safe across servers.** Servers that share an S3 bucket never both run the same slot.

## Chain tool calls without a model in between.

A workflow is a small Rust program of step functions compiled to wasm. Each step gets what the last call returned and answers with the calls to make next, in parallel if need be. It has no network of its own: the host makes the calls as the profile that runs it.

- **Called like a connector.** Start, read, stop and feed runs from an agent, the CLI, the API, or a `cron` schedule.
- **Retries and error paths.** Retry a failed call up to three times with backoff, then hand the error to a `catch` step.
- **Wait for events.** Park a branch until an event arrives, or sleep for a while, with timeouts.
- **See every run.** The web UI draws the graph and shows which step each branch is at.

```text title="callTool"
digest.tools startRun -b '{"input":{"city":"Berlin"}}'
digest.tools getRun -b '{"runId":"0k6832IujQX"}'
digest.tools sendEvent -b '{"runId":"0k6832IujQX",
  "event":"approved","payload":{}}'
cron.tools schedule -b '{"connector":"digest",
  "tool":"startRun","schedule":"0 9 * * mon-fri"}'
```

## Useful on the first run.

These ship inside the binary, with nothing to install. Most make no network calls and do the exact work models tend to get wrong by eye.

- **manage**: What the web UI does, as tools: install, configure, sign in and remove connectors.
- **cron**: Call any connector's tool on a schedule, as a profile.
- **workflows**: List, start, stop and feed workflow runs.
- **wasmrs**: Write a Rust connector, build it to wasm and install it, in the same session.
- **time**: Time zones, calendar-aware date math and business days, with the IANA database compiled in.
- **math**: Arithmetic, statistics and equations, through a safe parser that never runs code.
- **basic-finance**: Loans, mortgages, amortization, NPV, IRR, CAGR and more.
- **hash**: Digests, HMACs, encodings, password hashes, AEAD, Ed25519 and JWTs.
- **strings**: Exact counting, searching, regex, case and padding for text.
- **slices**: Filter, sort, group and set operations over JSON arrays.

## Write a connector in Rust, or have an agent write it.

The guest SDK and three starter templates (`minimal`, `api-key`, `oauth2`) get a connector building in minutes. A [Claude Code plugin](https://github.com/agentrq/mesher/tree/main/plugins/claude) and the `wasmrs` built-in let an agent build, test and install one itself.

```text title="callTool"
wasmrs.tools newProject -b '{"name":"weather","template":"api-key"}'
wasmrs.tools writeFile -b '{"project":"weather","path":"src/lib.rs",…}'
wasmrs.tools build -b '{"project":"weather"}'
manage.tools installBuilt -b '{"path":"…/weather.wasm"}'
```

- **Compiler errors come back as data.** File, line and message, so the agent can fix the code and build again.
- **Docs that agents can read.** The authoring guide, manifest reference and templates are served as MCP resources and skills.
- **Read the guides:** [authoring](https://github.com/agentrq/mesher/blob/main/docs/authoring.md), [manifest](https://github.com/agentrq/mesher/blob/main/docs/manifest.md) and [MCP compatibility](https://github.com/agentrq/mesher/blob/main/docs/mcp-compat.md).

## One static binary. Your machine or your cloud.

Plain HTTP on loopback for local use, or HTTPS with an automatic Let's Encrypt certificate. Keep data on disk or share an S3 bucket between servers.

### macOS

Apple silicon and Intel. Downloads the release binary for your CPU, checks its SHA-256 against the release’s `SHA256SUMS`, and installs to `~/.local/bin`.

```sh
$ curl -fsSL https://raw.githubusercontent.com/agentrq/mesher/main/scripts/install/install.sh | sh
$ mesher --version
$ mesher serve  # MCP at http://127.0.0.1:8080/mcp
```

Options: `sh -s -- --version v0.1.0` for a given release, `--dir PATH` to install elsewhere. [Read the script](https://github.com/agentrq/mesher/tree/main/scripts/install) before you run it.

Or run the container image:

```sh
$ docker run -d -p 8080:8080 \
    -e MESHER_TOKEN="$(openssl rand -hex 32)" \
    -v mesher-data:/data agentrq/mesher:latest
$ open http://localhost:8080
```

### Linux

x86_64 and arm64. Downloads the release binary for your CPU, checks its SHA-256 against the release’s `SHA256SUMS`, and installs to `~/.local/bin`.

```sh
$ curl -fsSL https://raw.githubusercontent.com/agentrq/mesher/main/scripts/install/install.sh | sh
$ mesher --version
$ mesher serve  # MCP at http://127.0.0.1:8080/mcp
```

Options: `sh -s -- --version v0.1.0` for a given release, `--dir PATH` to install elsewhere. [Read the script](https://github.com/agentrq/mesher/tree/main/scripts/install) before you run it.

Or run the container image:

```sh
$ docker run -d -p 8080:8080 \
    -e MESHER_TOKEN="$(openssl rand -hex 32)" \
    -v mesher-data:/data agentrq/mesher:latest
$ xdg-open http://localhost:8080
```

### Windows

x86_64, PowerShell. Downloads the release binary, checks its SHA-256 against the release’s `SHA256SUMS`, installs to `%LOCALAPPDATA%\Programs\mesher` and adds it to your `PATH`.

```powershell
PS> irm https://raw.githubusercontent.com/agentrq/mesher/main/scripts/install/install.ps1 | iex
PS> mesher --version
PS> mesher serve  # MCP at http://127.0.0.1:8080/mcp
```

Options: `-Version v0.1.0` for a given release, `-Dir PATH` to install elsewhere (save the script first). [Read the script](https://github.com/agentrq/mesher/tree/main/scripts/install) before you run it.

Or run the container image:

```sh
PS> $token = [Convert]::ToHexString(
    [Security.Cryptography.RandomNumberGenerator]::GetBytes(32))
PS> docker run -d -p 8080:8080 -e MESHER_TOKEN=$token `
    -v mesher-data:/data agentrq/mesher:latest
```

## Open source, with a commercial option.

Open source

### AGPL-3.0

Free to use, change and self-host. If you offer a modified version over a network, you share your changes under the same license.

[Read the license](https://github.com/agentrq/mesher/blob/main/LICENSE)

Commercial

### Commercial license

For proprietary use without the AGPL's obligations. Licence keys are verified offline; nothing phones home.

[Contact hi@mesher.sh](mailto:hi@mesher.sh?subject=Mesher%20commercial%20license)

## Connect your agents to everything, safely.

[Get started](https://mesher.sh/#install)

[Star on GitHub](https://github.com/agentrq/mesher)
