MCP Connector

Control and reuse agent workflows

Coral gives agents policy-checked access to services through TypeScript programs and reusable custom tools on your own infrastructure.

Works with githubslacklinear

75
Spark score
out of 100
Updated 5 days ago
Source checked Nov 16, 2026
Version 1.8.0
Models
claude

Add to Favorites

Why it matters

Run repeatable agent workflows across connected services within workspace access policies.

Outcomes

What it gets done

01

Discover available provider tools

02

Check provider calls against workspace policy

03

Approve restricted operations

04

Save and share successful programs

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Overview

Coral is a self-hosted gateway that executes agent-written TypeScript programs against connected services. It checks each provider call against workspace policy, manages credentials, and lets successful programs become reusable private or shared tools. Use it for recurring agent workflows that need per-call access policies and human approval. Teams can apply custom tools to scoped SRE, support, analytics, and SecOps operations.

What it does

Coral is an open-source, self-hosted gateway between agents and the systems they use. An agent sends short TypeScript programs that can call several tools, filter responses, and return only the information needed for a task. Successful programs can become reusable custom tools, reducing the need to rediscover schemas and rewrite the same steps on later runs.

Each program executes in a fresh V8 isolate without network access, credentials, or imports. Coral checks each provider call against workspace policy before adding credentials and forwarding it. Execution happens on the Coral server and continues if the agent disconnects. Every run is attributed to the person or agent that started it, and approvals are logged.

When to use - and when NOT to

Use Coral when agents need controlled access to services and repeatable ways to complete recurring tasks. Its documented pull-request workflow finds GitHub pull requests without reviewers, requests approval before posting to Slack, and saves the working program for reuse the next day. The program returns pull request numbers rather than the full GitHub response.

Coral fits workflows where authorization needs to constrain the operation itself. For example, a custom tool can change one field only on tickets without activity for 30 days. It is less suited to a migration that must preserve Coral 0.x state: v1 replaces the SQL interface with TypeScript programs, starts from fresh state, and does not convert the older stored data. Existing 0.x state is reported at startup.

Capabilities

Agents use the exec tool to send programs and coral.search to discover available tools and their TypeScript signatures. Provider tools and custom tools appear in the same search. A successful program can be saved privately and called through coral.private; workspace owners can publish it under coral.shared for everyone in the workspace.

Allow, Ask, and Block policies apply to both provider tools and custom tools. Checks still apply to every provider call inside a custom tool. An approval displays the exact call and its arguments, allowing a person to authorize a particular operation. By default, tools that read data run immediately, while other operations require approval.

A provider represents a connected service, such as GitHub or Linear. Providers can come from the catalog, an OpenAPI document, or an MCP server. A provider can use each caller's own account so teammates share tools without sharing API tokens. Programs can combine calls and filter results before returning data to the agent. Runs also leave structured traces of the goal, tools used, and outcome that can support model post-training.

How to install

For individual use, download the desktop app for macOS on Apple silicon, Windows on x64, or Linux on x86_64. For a team, run a shared server with Docker Compose or Kubernetes. The shared setup requires an OIDC identity provider, a reverse proxy for TLS, and SQLite or Postgres.

Add a provider, then copy the workspace MCP URL from the Coral UI into your client configuration. The documented Claude Code command is:

claude mcp add --scope user --transport http coral <your-mcp-url>   # Claude Code

The setup also provides a Codex command and connection instructions for Cursor, VS Code, OpenCode, and other MCP clients. Once connected, ask a question that uses the provider, such as requesting your open pull requests.

Coral is written in Rust and can run on a laptop or in your own cloud. Its open-source edition uses the Apache License 2.0 without limits on users, agents, or volume. Enterprise Edition code has a separate license; a plain cargo build at the repository root builds only Apache License 2.0 code.

Who it's for

Coral serves individual developers and teams working in SRE, customer support, business intelligence, and SecOps. Documented applications include investigating alerts with rollback limited to named services, issuing refunds with human escalation in defined cases, aggregating warehouse, CRM, and billing data into metrics, and isolating devices within approved groups. Workspace owners can share the resulting tools across their teams.

Source README

Coral, with engraved orange corals

Coral

Execution rails for agents.

Coral is an open-source, self-hosted gateway that sits between your agents and the systems they work on. Agents call tools by writing short TypeScript programs, and save the ones that work as custom tools to reuse. Coral checks every call against your policy before it adds credentials and forwards the call.

Quickstart · Download · Demo video

In this example, an agent posts unreviewed PRs to Slack for the first time. The agent searches for the GitHub and Slack tools and writes code that calls them. It isn't allowed to post to Slack without approval, so the user approves the post. The agent then saves its code as a custom tool. The next day, the agent runs the same task by calling that custom tool.

In Claude Code, an agent posts unreviewed pull requests to Slack. It searches Coral for the GitHub and Slack tools, writes code that calls them, and waits for approval before posting. The Coral UI then shows the run, who approved it, and the custom tool the agent saved. The next day, the same request runs by calling that custom tool. A final card compares the two days: 35% fewer tokens and 31% faster, in line with our benchmarks.

Control what agents can do, not just what they can reach. Most MCP gateways decide only which tools an agent can see. That is all or nothing: if an agent can call update_record, it can update any record in any way the tool allows. A custom tool is code, so it can hold the rule that Allow and Block cannot: closeStaleTicket changes one field, only on tickets with no activity for 30 days. You set Allow, Ask, or Block on the custom tool like any other tool, and Coral still checks every provider call inside it against your policy.

Less duplicated agent work. Agents start every task from scratch. They re-read tool schemas, retry failed calls, and spend tokens rewriting code for steps they got right yesterday. With Coral, agents save the code that worked as custom tools they call again in one step, and workspace owners can share them with the whole team.

Coral is used by thousands of developers at more than 450 companies for safer, more efficient agent work in customer support, SecOps, business intelligence, SRE, and more.

Get started

  1. Install Coral.

    • For yourself: download the desktop app from the download page. It runs on macOS (Apple silicon), Windows (x64), and Linux (x86_64).
    • For your team: run a shared server with Docker Compose or Kubernetes. You need an OIDC identity provider, a reverse proxy for TLS, and SQLite or Postgres.
  2. Add a provider. A provider is one service your agents can use, such as GitHub or Linear. Pick one from the catalog, or bring your own OpenAPI document or MCP server. By default, tools that read data run right away and everything else needs your approval. See Add a provider.

  3. Connect your agent. Copy your workspace's MCP URL from the Coral UI and add it to your MCP client:

    claude mcp add --scope user --transport http coral <your-mcp-url>   # Claude Code
    codex mcp add coral --url <your-mcp-url>                            # Codex
    

    For Cursor, VS Code, OpenCode, and other clients, see Connect an MCP client.

  4. Ask a question. Ask your agent something that uses that provider, such as "What are my open pull requests?"

Why Coral

We started Coral while building an AI SRE. To investigate an incident, the agent had to connect the dots across an ocean of telemetry and undocumented relationships between internal and external systems. It needed broad permissions and a lot of tokens, and it started from scratch the next time.

We built Coral so that the agent remembers the route. Once a task succeeds, the agent saves the steps that worked as a custom tool. Next time, it finds that tool in the same search as provider tools such as Datadog and Slack. It started with SRE, and teams now use Coral for agent work across the organization:

  • SRE. The agent investigates alerts. Custom tools let it roll back only the services you name.
  • Customer support. The agent issues refunds, and escalates to a person in the cases you define.
  • Business intelligence. Custom tools aggregate warehouse, CRM, and billing data, and pass only the metrics to the agent.
  • SecOps. The agent uses custom tools to isolate devices within approved groups.

What you get:

  • Precise control. Set Allow, Ask, or Block for each provider tool and each custom tool. An approval shows the exact call and its arguments, so Security approves one refund lookup, not the whole payments API. See Roles & Permissions.
  • Shared tools, not shared tokens. You can set each provider to use the caller's own account, so teammates share tools without sharing API tokens. Read how Slackbot uses this.
  • Cheaper models, same accuracy. With custom tools, a smaller model performs like a bigger one. For many tasks, this means Opus 5.5 accuracy at Haiku 5.5 cost.
  • Faster, leaner agents. Across 34 tasks on GitHub, Linear, and Slack with Opus 5.5, custom tools cut tokens by 37%, cost by 31%, and time by 29%. See every task.
  • Ahead of other MCP gateways. In blind benchmarks of 100 enterprise tasks, agents were more accurate and cheaper with Coral than with other MCP gateways. See the benchmarks.
  • Training data you own. Each run leaves a structured trace of the goal, the tools used, and the outcome that works well for post-training your own model.

From one developer's laptop to an enterprise cloud, Coral fits your stack:

  • Runs on your infrastructure. Coral is written in Rust and runs as a desktop app on your laptop or a shared server in your own cloud, with zero data egress.
  • Open source. Coral is licensed under the Apache License 2.0, with no limits on users, agents, or volume. Everything in this README outside Coral Enterprise is in the open-source edition.
  • Any agent, any system. It works with any AI app or agent that supports MCP. You can connect anything with an MCP server or OpenAPI document, including more than 5,000 databases and SaaS tools.

How Coral works

Agents write programs. Coral builds on code mode, and adds custom tools, policy controls, and managed identities. To use tools, an agent writes a short TypeScript program. One program can call several tools, filter the results, and return only what the task needs. Less raw data passes through the model's context.

Coral runs them on rails. Each program runs in a fresh V8 isolate with no network access, no credentials, and no imports. Coral checks every tool call against your workspace policy, then adds the credentials and forwards the call to the provider. A policy can also require a person to approve the call. Every run is attributed to the person or agent that started it.

graph LR
    Agent["Your agent"] -->|"exec: run a program"| MCP["Coral MCP server"]
    You["You"] -->|"providers, policy, approvals"| UI["Coral UI"]

    subgraph Coral["Coral (your laptop or server)"]
        MCP --> Run["Program runs in a V8 isolate"]
        Run <--> FN["Custom tools (private and shared)"]
        UI --> Gate["Policy check and credentials"]
        Run --> Gate
        Gate -.->|"approval request"| UI
    end

    Gate --> GH["GitHub"]
    Gate --> SL["Slack"]
    Gate --> Own["Your OpenAPI or MCP service"]

The agent sends Coral programs through the exec tool. A program calls coral.search to find the tools the agent can use and read their TypeScript signatures. Then the agent sends a program that does the work. This one finds open pull requests that have no reviewer and posts them to Slack:

const { data: pulls } = await coral.providers.github.pulls.list({
    owner: "withcoral",
    repo: "coral",
    state: "open",
});

const unreviewed = pulls.filter((pull) => pull.requested_reviewers.length === 0);

await coral.providers.slack.chat.postMessage({
    channel: "#engineering",
    text: unreviewed.map((pull) => `#${pull.number} ${pull.title}`).join("\n"),
});

return unreviewed.map((pull) => pull.number);

If posting to Slack needs approval, the run pauses there until you approve it. Only the pull request numbers go back to the agent, not the full GitHub response. The run happens on the Coral server, not in your agent, so it carries on even if the agent disconnects.

What works becomes a custom tool. When a program succeeds, the agent saves it as a private tool and calls it next time in one step as coral.private.<name>({ ... }). Agents find custom tools in the same search as provider tools, and reuse or edit them instead of starting over. A workspace owner can publish a private tool as a shared tool under coral.shared, so everyone in the workspace can call it.

To learn about providers, accounts, policy, and workspaces, read Concepts.

For teams and enterprise

Running Coral for a team? See Run a shared server.

Coral Enterprise is coming soon under its own license. It adds organization-wide governance and support: SSO with SAML, SCIM provisioning, advanced RBAC, an immutable audit log, and support SLAs. See Coral Enterprise or book a demo.

Development

To run Coral from a checkout, follow the development guide. To contribute, read CONTRIBUTING.md. The release notes list what changed in each version.

Community

Ask questions, share ideas, and show what you built in our Slack community or on GitHub issues.

Security

Do not report security issues in public issues or pull requests. See SECURITY.md.

Coral is ISO/IEC 27001:2022 certified. Each program runs in its own V8 isolate, and Coral logs every approval.

Upgrade from Coral 0.x

Coral v1 replaces the SQL interface with TypeScript programs. It starts from fresh state and does not convert what 0.x stored. If Coral finds 0.x state, it tells you at startup. See Upgrade from Coral 0.x.

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.