Build any MCP server. Run every tool behind one endpoint.

ray.run puts one virtual MCP server in front of every tool your agents call. Give Codex, Claude Code, or another coding agent an idea and deploy the complete server it builds, or connect remote MCP, OpenAPI, npm, and container services. They all use one URL.

Every client you run holds every server, and a copy of every credential:

{
  "mcpServers": {
    "linear":       { "url": "…", "headers": { "Authorization": "Bearer …" } },
    "stripe":       { "command": "npx", "env": { "STRIPE_API_KEY": "sk_live_…" } },
    "notion":       { "command": "npx", "env": { "NOTION_TOKEN": "ntn_…" } },
    "internal-api": { "command": "node", "env": { "API_KEY": "…" } }
  }
}

ray.run replaces all of it with one entry, and holds the credentials itself:

{
  "mcpServers": {
    "ray.run": {
      "url": "https://ray.run/mcp"
    }
  }
}

Create your endpoint Build an MCP server

Every client addresses the same endpoint. ray.run attaches each service’s stored credential on the way out, and records the call either way.

From an idea to a live MCP server.

you → Codex
Build a Hacker News digest MCP.
Add get_top_stories({ limit }), test it,
and deploy it to Rayrun.

Codex  server implemented · tests passed
$ rayrun deploy --wait
Rayrun validation passed · source uploaded
Rayrun Tracking build build_7f3d · resume command printed
Rayrun build succeeded · release active · get_top_stories

you → Claude
Use my Hacker News server to summarize
today's top five stories.

rayrun init scaffolds a complete TypeScript server. Add --template fastmcp for Python. Ask your coding agent to implement the whole service—one tool or many—then deploy the project with one command.

The recommended stack is Node.js 24, ViteMCP, Zod, and Vitest. It is a golden path, not a lock-in: Rayrun accepts locked Node or Python projects that expose a Streamable HTTP MCP endpoint at /mcp on PORT.

Rayrun encrypts the source, builds it remotely in isolation, verifies a candidate with tools/list, and changes the live release only after verification succeeds. See source deployment.

Connect what already exists.

[mcp]
Remote MCP
Point ray.run at a remote MCP server. It completes the OAuth flow, holds the token, and re-exposes that server’s tools under your endpoint.
[openapi]
OpenAPI
Hand it an OpenAPI document. Each supported operation becomes a typed tool, and authorization-code OAuth uses the same personal or shared credential vault as MCP.

As services accumulate, their tool definitions consume more context. Code mode exposes two tools and searches the catalog at call time. It is the default endpoint. How code mode works.

Give agents the workflow beside the tools.

Publish versioned Agent Skills through the same endpoint. Compatible clients discover only the guidance they are authorized to receive. Drafts, publishing, audience, and history stay in the workspace.

Skills use the draft SEP-2640 MCP extension and do not change tool policy. Other clients continue working normally. How Workspace Skills work.

Adapt the tool once, before every agent sees it.

Hosted TypeScript hooks adapt an indexed tool in one place. Change its public contract, transform arguments or results, reject a call, or require approval for the transformed request.

Edit with generated types in the browser or your repository. Test with mocks, observe a shadow revision, inspect run logs, and roll back without rebuilding.

Hooks cannot access the network, filesystem, environment, credentials, or other tools. How hosted tool hooks work.

Set access for each tool.

Allow safe actions, ask before changes, or block an individual tool. Start with one default for the service, override it for individual tools, then let each connected client narrow access further.

A tool's first definition is approved when the service is indexed. Later changes to its description or inputs stay unavailable until you approve the exact new version. How access works, how tool changes are reviewed.

One place for credentials. One record of every call.

Tokens live with ray.run, not with the client. Revoke a service once instead of updating every laptop that configured it. Rayrun renews upstream access before expiry when the provider supplies a refresh token. Otherwise, it prompts you to reauthorize.

Calls your policy turns down are recorded too, and a description that changed after you approved it stays unavailable until you review it. How credentials are held, what happens when a tool changes.

Filter calls by person, client, service, tool, outcome, or credential identity. Bookmark or export an investigation, compare failure rate and p95 latency, and see when response rules removed data. Unknown outcomes are labelled for verification instead of reported as safe to retry.

The terminal is a first-class client.

rayrun setup detects supported MCP clients, changes only the targets you choose, and keeps byte-for-byte backups with a rollback command. No bearer token or API key is written into client configuration.

rayrun setup --login runs supported client login commands for Claude Code, Codex, and Devin. It does not authenticate the Rayrun CLI: after client login succeeds,rayrun status can still report missing CLI credentials. Run rayrun login separately.

Inspect identity and health with rayrun status and rayrun doctor. Contextual help, shell completion, and a machine-readable command schema make the same interface discoverable to people, agents, and wrappers. Automation can disable prompts and progress, paginate results, and rely on stable exit codes. With --json, it can also select fields and receive structured errors on stderr.

Operators can describe and call tools, resume an exact browser-approved call, and list connections, policies, approvals, and Activity. Hook authors can test, deploy, roll back, and inspect logs. Server authors can scaffold a complete ViteMCP project, deploy source, retain its recovery command while following the build, and promote an older verified release. Execution uses browser OAuth. For workspace administrators, the same rayrun login approval also creates an audience-bound management token. CI and unattended automation use a scoped API key. Run ray.run from the CLI.

Start with one server.

Connect a single service, point one client at it, and add the rest when you are ready. Nothing has to move at once.

Create your endpoint