runelay
Connects a GitHub account once, via one-click OAuth, so every connected agent shares the same GitHub tools and repository context from the user's own server.
Connects a Linear account once, via one-click OAuth, so every connected agent shares the same Linear tools and issue-tracking context from the user's own server.
Connects a Notion account once, via one-click OAuth, so every connected agent shares the same Notion tools and workspace context from the user's own server.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@runelay search my shared memory for notes about the staging deploy"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
✨ Why
Every agent lives on its own island. You log into Linear four times, copy the same skill to four folders, and teach Claude a rule that Codex never hears about.
runelay is the bridge: one MCP endpoint, on your server, in front of every account, skill and memory. It runs no model. Your agent thinks; runelay is where it finds tools and context.
flowchart LR
subgraph A[" Your agents "]
CC[Claude Code]
CX[Codex]
CU[Cursor]
GK[Grok]
end
R((runelay))
subgraph B[" Your stuff "]
AC[Linear · GitHub · Notion · any OpenAPI]
SK[Skills]
ME[Memory]
end
CC & CX & CU & GK -- "Bearer rnl_…" --> R
R --> AC & SK & ME
classDef hub fill:#f0a050,stroke:#f0a050,color:#111,font-weight:bold
class R hubRelated MCP server: mcp-workstation
🧩 What you get
🔌 Connect once | ~25 curated MCP servers with one-click OAuth, plus any remote MCP, local MCP or OpenAPI spec. |
🧠 Shared memory | Notes linked with |
📚 Skills that travel | Your |
📥 Import in one go | Memories, skills and instructions from Claude Code, Codex, Cursor, Grok, Gemini and OpenCode. |
🔑 One key per agent | Revoke one without touching the others. Every call audited. |
🏠 Yours | One container, SQLite, no third-party services. MIT. |
🚀 Quick start
curl -fsSL runelay.com/install | shThat is it. The script creates ~/runelay, writes a .env with a fresh RUNELAY_SECRET, pulls the image and starts it on 127.0.0.1:4312. Open the link it prints, create your account and follow Acesso → Configurar agentes.
Or the desktop app
No Docker needed: grab runelay for Mac (Apple silicon), Mac (Intel), Windows or Linux (AppImage, also for arm64). The app runs the same server on 127.0.0.1:4312, so the CLI and your agents find it on their own. Data lives in the app folder (~/Library/Application Support/runelay on Mac); the secret is kept in the system keychain when one is available.
The builds are not signed yet. On Mac, right-click the app and choose Open the first time. On Windows, choose More info → Run anyway. Keep the app running while your agents use it; quitting it stops the server.
Migrate in one command
On the computer where your agents live:
curl -fsSL runelay.com/cli | sh
runelay migratemigrate logs in through the browser if needed, then reads Claude Code, Codex, Cursor, Grok, Gemini and OpenCode: MCP servers, memories, skills and global instructions. It shows a summary per agent, asks once and sends everything.
Comes connected: OAuth accounts the agent already logged into. runelay reads the tokens Grok keeps in
~/.grok/mcp_credentials.jsonand, on macOS, the ones Codex and Claude Code keep in the Keychain (macOS may ask for permission). Servers that authenticate with headers come connected too.Asks for login: everything else, including Cursor accounts (Cursor encrypts its tokens). At the end the CLI opens
/connectors/reconnect, a queue that walks you through the remaining logins one tab at a time.Stays on the agent: local command servers (stdio). Add them from the panel if you want them in runelay.
Token rotation: many providers rotate the refresh token on use. Once runelay refreshes it, the old agent may ask you to log in again. Run with
--replace(or answert) to remove the migrated MCPs from the agents and leave only runelay.
runelay migrate --yes skips the question (required without a terminal). Tokens are sent only to your server and stored encrypted.
Options go in front of sh:
curl -fsSL runelay.com/install \
| PUBLIC_URL=https://runelay.example.com RUNELAY_DIR=/opt/runelay RUNELAY_VERSION=v0.1.0 shUpdate: click the update button in the panel rail when a new release is out, or run cd ~/runelay && docker compose pull && docker compose up -d.
services:
runelay:
image: ghcr.io/andsu-dev/runelay:latest
restart: unless-stopped
env_file: .env
environment:
RUNELAY_UPDATER_URL: http://updater:8080
labels:
com.centurylinklabs.watchtower.enable: "true"
ports:
- "127.0.0.1:4312:4312"
volumes:
- ./data:/data
updater:
image: containrrr/watchtower:1.7.1
restart: unless-stopped
command: --http-api-update --label-enable --cleanup
environment:
WATCHTOWER_HTTP_API_TOKEN: ${RUNELAY_UPDATER_TOKEN:-}
DOCKER_API_VERSION: "1.44"
volumes:
- /var/run/docker.sock:/var/run/docker.sockThe updater service is optional. It powers the one-click update in the panel and only touches containers labeled for it. Leave it out if you do not want a container with access to the Docker socket.
PUBLIC_URL=https://runelay.example.com # the URL people and agents use
RUNELAY_SECRET=$(openssl rand -hex 32) # encrypts connections and API keys; back it up
ALLOW_SIGNUP=false # first signup becomes the owner, then signups close
RUNELAY_UPDATER_TOKEN=$(openssl rand -hex 24) # lets the panel ask the updater for a new releasegit clone https://github.com/Andsu-dev/runelay.git && cd runelay
cp .env.example .env # set PUBLIC_URL and RUNELAY_SECRET
docker compose up -d --build
bun run devis only for working on runelay itself. To run it, use the image.
Caddy
runelay.example.com {
reverse_proxy 127.0.0.1:4312
}Cloudflare Tunnel
ingress:
- hostname: runelay.example.com
service: http://127.0.0.1:4312
- service: http_status:404OAuth callbacks go to PUBLIC_URL/v1/oauth/callback, so PUBLIC_URL must be the public address.
Variable | Default | Description |
|
| Public URL of the panel and API. Used for OAuth callbacks and cookies. |
| required, 32+ chars | Encrypts connection configs, OAuth tokens and recoverable API keys. Losing it means reconnecting everything. |
| generated | One-time token required to create the first account. |
| generated | Shared with the |
| set by | Where the updater listens. |
|
| Keep signups open after the first account. |
|
| Enables the sandboxed |
|
| Enables local MCP servers by command. See Security. The Docker image ships without Node, so commands like |
|
| Allows connections to private network addresses. |
|
| Requests per minute allowed for each API key. |
| empty | Enables "Sign in with GitHub" on the panel. |
|
| Where the SQLite database lives. |
|
| Where the server listens. |
🤖 Connect your agents
In the panel, open Acesso → Configurar agentes. The guide walks you through connecting accounts, creating a key and wiring each client.
Or paste the config yourself (replace the URL and key):
Claude Code
claude mcp add --scope user --transport http runelay https://runelay.example.com/v1/mcp \
--header "Authorization: Bearer rnl_..."Codex (~/.codex/config.toml)
[mcp_servers.runelay]
url = "https://runelay.example.com/v1/mcp"
http_headers = { Authorization = "Bearer rnl_..." }Grok (~/.grok/config.toml)
[mcp_servers.runelay]
url = "https://runelay.example.com/v1/mcp"
headers = { Authorization = "Bearer rnl_..." }Cursor (~/.cursor/mcp.json)
{ "mcpServers": { "runelay": { "url": "https://runelay.example.com/v1/mcp", "headers": { "Authorization": "Bearer rnl_..." } } } }All of them at once with the CLI (see below): runelay login, then runelay connect.
📥 Bring your context
The runelay CLI runs on your computer, because that is where your agents keep their files. Install it, log in through the browser, done: no env vars, no keys to copy.
curl -fsSL runelay.com/cli | sh
runelay login # finds your server, opens the browser, saves this computer's key
runelay status # server, organization and what is stored in it
runelay push # memories, skills and global instructions from every installed agent
runelay pull # brief into CLAUDE.md and AGENTS.md, new skills into ~/.claude/skills
runelay sync # push, then pull
runelay connect # registers the runelay MCP in Claude Code, Codex, Cursor and Grok
runelay import # MCP servers from Claude, Codex, Grok and Cursor configs become connections
runelay logout # revokes this computer's key and clears the configrunelay login looks for PUBLIC_URL in ~/runelay/.env (what the installer writes), then for http://localhost:4312, and asks before using what it found. You can also pass the address: runelay login https://runelay.example.com. The browser shows a code: check it matches the terminal and approve. The key shows up in the panel as CLI <device> and is saved in ~/.config/runelay/config.json (mode 600, XDG_CONFIG_HOME respected).
The installer puts the binary in ~/.runelay/bin (change it with RUNELAY_INSTALL_DIR, pin a release with RUNELAY_VERSION=v0.2.0) and adds it to your shell PATH.
CI / env vars. RUNELAY_URL and RUNELAY_API_KEY override the saved config, so a pipeline can run runelay push with a key created in the panel. Inside a clone of this repo, bun run import-context, sync-context, install-clients and import still work and map to push, pull, connect and import.
runelay push reads:
Agent | Skills | Memory and instructions |
Claude Code |
|
|
Agents (universal) |
| |
Codex |
|
|
Cursor |
| |
Grok |
|
|
Gemini |
|
|
OpenCode |
|
|
Duplicates are merged (first one wins). Memories listed under ## Regras de ouro in a MEMORY.md, and global instruction files, come in pinned.
runelay pull only touches the block between <!-- runelay:start --> and <!-- runelay:end -->. Everything else in your files stays as it is. The brief tells agents to save new facts with write_memory, so memory flows back to runelay instead of local files.
Enabled skills you do not have in any agent folder are written to ~/.claude/skills/<slug>/ with a .runelay marker. Later pulls update only marked folders and push skips them. A folder without the marker is yours and is never overwritten.
📖 Reference
Tool | What it does |
| Every connection with status and tool count. |
| Search tools across all connections ( |
| Call one tool with arguments. |
| Run JavaScript that chains tools inside a WebAssembly sandbox: |
| Full-text search across memories and skills. |
| Read a memory, or create and update one (versioned). |
| Read a skill and its files. |
Everything the panel does goes through a versioned JSON API. Every response is { data, error }.
Method | Route | Auth |
|
| better-auth (email and password, GitHub) |
GET |
| session |
GET, POST |
| session |
GET, POST |
| session |
POST, GET |
| public, rate limited |
GET, POST |
| session |
GET, DELETE |
| API key (status also session) |
GET, POST |
| session or API key |
GET, PATCH, DELETE |
| session or API key |
GET, POST |
| session or API key |
GET, POST, PATCH, DELETE |
| session or API key |
GET, POST, PATCH, DELETE |
| session or API key |
GET |
| session or API key |
GET |
| session or API key |
|
| API key |
runelay holds credentials for every account you connect, so it is locked down by default.
First access. While no account exists, signing up needs a one-time setup token. The installer generates it and prints the link (/login?mode=signup&token=…). Without RUNELAY_SETUP_TOKEN in .env, the server makes one at startup and prints the link in docker compose logs. After the first account, signups close (unless ALLOW_SIGNUP=true).
Credentials.
Connection configs, OAuth tokens and recoverable API keys are encrypted with AES-256-GCM using
RUNELAY_SECRET.Agents never receive credentials: requests made with an API key, and the
list_connectionstool, see headers and env values as••••••.Importing a client config through the API never expands
${VARS}from the server environment.API keys belong to one organization. Revealing a key needs a panel session, never an API key.
Risky capabilities.
Variable | Default | What it unlocks |
|
| The |
|
| Local MCP servers ( |
|
| Connections to private, loopback, link-local and CGNAT (100.64.0.0/10) addresses (SSRF protection: cloud metadata, other services on the host). |
Prompt injection. Tool results come from third parties (an issue, a page, an email). runelay limits what a manipulated agent can do: it cannot read credentials, cannot pin memories (pinned memories go into every agent's instructions, so only the panel can pin) and execute code runs in a WebAssembly sandbox with no access to the server. It can still write unpinned memories and call the tools you connected, so review memory health from time to time.
Abuse and visibility.
Every API key has a sliding-window rate limit (
RUNELAY_RATE_LIMIT_PER_MINUTE, default 240). Over the limit the API answers429withretry-after.Every request made with an API key is audited: tool calls (source, tool, result, duration) and REST calls (method, path, status, IP). Open Chaves de API → Atividade to see one key's timeline.
Network. Every outgoing request (MCP, OAuth, OpenAPI) resolves DNS and checks the address right before it goes out, and redirects are followed one hop at a time with the same check, so DNS rebinding and redirects cannot reach private addresses.
Container. The image starts as root only to fix the ownership of /data, then drops to the unprivileged node user. The application code stays read-only for that user. Keep the 127.0.0.1 binding (the default) and put HTTPS in front.
Backup: copy the data/ folder (the SQLite database) and keep RUNELAY_SECRET somewhere safe. Both are needed to restore.
Update: the panel shows an update button when a new release is out (owners and admins, with the updater service). By hand: docker compose pull && docker compose up -d (or git pull && docker compose up -d --build from source). Migrations run on startup.
Health: GET /health returns ok. The container has a healthcheck.
bun install
cp .env.example .env # PUBLIC_URL=http://localhost:5173 for dev
bun run seed # demo user, organization, connections and an API key
bun run dev # API on :4312, panel on :5173 (Vite proxies /v1)apps/
api/ Hono + better-auth + SQLite. Feature modules in src/modules/<feature>/{routes,services,repositories,...}
web/ React + Vite + TanStack Router/Query + Tailwind + motion
cli/ the runelay CLI: login, status, push, pull, sync, connect, import, logout
packages/
shared/ zod schemas, types and the { data, error } Result used by every appScript | |
| API and panel with hot reload |
| Builds the panel (served by the API in production) |
| Compiles the CLI for macOS and Linux into |
|
|
| Biome format and lint |
| Demo data for local development |
🗺️ Roadmap
Tools page with per-tool approval policies
Organization members and invites
Activity log per API key
Menu bar app for macOS (reconnect alerts)
Available Tools
9 toolscall_toolC
Call one tool by its full name (source.tool) with arguments.
Inputs: name (required), args.
executeA
Run an async JavaScript snippet that chains tools across sources. Each tool is tools.<source>.<tool>(args) and resolves to { data, error }. return the final value; console.log output comes back in logs. Use search_tools first to learn the schemas.
Inputs: code (required).
list_connectionsA
List every connected source with status, tool count and the link to reconnect it.
Inputs: no named parameters.
read_memoryA
Read one memory by slug, with its body, links and backlinks.
Inputs: slug (required).
read_skillB
Read one skill by slug: its full instructions and the list of extra files.
Inputs: slug (required).
read_skill_fileC
Read one extra file of a skill by its path.
Inputs: path (required), slug (required).
search_contextB
Full-text search across the user's memories and skills. Returns slug, name, description and a snippet, best match first.
Inputs: query (required), kind, limit.
search_toolsB
Search tools across all connected sources. Returns full input schemas when 10 or fewer match. An empty query lists every tool.
Inputs: limit, query, source.
write_memoryB
Create or update a memory by slug. Updating keeps the previous content as a version. Link other memories with [[slug]] in the body.
Inputs: body (required), slug (required), name, type, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
The tools mostly target distinct areas: tool discovery/execution, connection listing, memory, and skills. call_tool and execute overlap slightly because both can invoke tools, and search_tools with an empty query overlaps with list_connections, but the descriptions make the intended distinctions clear enough.
Almost all tools follow a consistent snake_case verb_noun pattern such as call_tool, list_connections, read_memory, search_tools, and write_memory. execute is the only notable deviation as a bare verb, but the overall convention remains predictable.
Nine tools is well scoped for an agent runtime covering tool discovery, execution, memory, and skills. Each tool has a clear role without excessive surface area.
The set covers core workflows: discovering and calling tools, executing chained calls, managing memories, and reading skills. Minor gaps exist, such as no delete_memory or explicit list_memories/list_skills operations, but agents can mostly work around these with search and read tools.
Maintenance
Related MCP Connectors
MCP gateway and cloud hosting for MCP servers, agents and apps like RAG, managed from your agent.
- aXDeprecatedio.github.ax-platform
Agent-native collaboration network: orchestrate a team of long-running agents from any MCP client.
Hosted MCP server and Agent Skills for specs, engineering threads, and project memory.
One profile — skills, credentials, and memory — synced to every agent tool via one MCP URL.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables AI clients to connect once and access tools from many registered MCP servers plus built-in modules, with multi-user authentication, per-user server/tool toggles, and a skills hub.MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI clients to connect to a single MCP endpoint that aggregates many MCP servers and built-in tools, with multi-user authentication, per-user server configuration, encrypted secrets, and a skills hub.MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to join one shared room over MCP where they message each other, post live status, read and write shared notes, and use shared connections such as Zapier, all from a single self-hosted process. Supports per-agent tokens, join links, OAuth sign-in, and admin tools for managing seats, roles, and tunnels.1 npmMIT
- AlicenseNot gradedqualityCmaintenanceRuns each MCP server once and lets any number of AI agents connect over HTTP with their own keys, per-tool grants and audit logging, plus a shared task list, shared memory and agent-to-agent requests. Enables agents to work as a coordinated team without duplicating processes, credentials or work.7 npmMIT