Ridge

A resource mesh for AI agents

Give your agent resources. Let it build the team.

Ridge works with Codex, Claude Code, and agents built with LangChain, connecting them to resources such as local projects, remote compute, containers, and cloud storage.

Your agent discovers what's available, delegates tailored access to subagents, and brings their results together. Each child gets the resources and permissions its task needs, while Ridge coordinates shared work and keeps access within the boundaries you establish.

Configure access once. Let agents divide it up for the task.

Bring your existing tools: connect through MCP, bundle Ridge's skill and tools as a local plugin, or build on its Python API. Connect your agent →

From one request to a team of agents

Compare two approaches to a data-analysis problem. The project lives on your laptop, the dataset is in cloud storage, and two remote workers are available to run the evaluations. With these resources connected through Ridge, your agent can divide the work and give each child its own access.

You ask:

Compare these two approaches. Have an agent evaluate each against the dataset, save their results, and tell me which performs better.

The agent discovers the available resources and delegates access:

No separate inventory for each agent. No manual permission edits between tasks.

The parent creates each child's access through Ridge:

# Parent agent's Ridge MCP call:
create_scope(
    grants=[
        {
            "resource": "project",
            "operations": ["data.read", "data.stat"],
        },
        {
            "resource": "datasets",
            "operations": ["data.read", "data.stat"],
        },
        {
            "resource": "worker-a",
            "operations": [
                "compute.exec",
                "data.read",
                "data.write",
                "data.stat",
            ],
        },
        {
            "resource": "results",
            "operations": ["data.read", "data.write", "data.stat"],
            "data_root": "comparison/a",
        },
    ]
)

The agent harness launches the child with the returned access handle bound to its Ridge connection. The parent repeats this for Agent B with its own worker and results prefix.

Each child copies its inputs, runs its evaluation, and publishes results. Within Agent A's view, saving results:metrics.json writes to comparison/a/metrics.json.

The parent follows their background jobs, compares the reports, and revokes task access when finished. Children can delegate further when the parent allows it.

The example assumes configured resources, evaluation code, and a policy permitting delegation. Ridge manages resource access and coordination; the agent harness handles spawning and dispatch. Follow the delegation guide or try the runnable handoff example.

Why Ridge?

• Delegate access, not just instructions. Give subagents selected resources, permissions, and narrower data locations. They receive task-specific access—not the parent's entire authority.
• Bring different resources into one workflow. Agents work with named resources across machines and services without assembling backend-specific glue for every task.
• Keep artifacts out of model context. Stream datasets, source trees, models, and reports between resources. Agents read back what matters.
• Coordinate shared work. Ridge prevents conflicting participating operations from overlapping. Independent S3 objects can be accessed concurrently; sessions reserve resources across multi-step workflows.
• Pick up work later. Background jobs have durable IDs, results, and logs. Reconnect to inspect progress, and let parents supervise delegated work.
• Keep control as work evolves. Bound further delegation, set task expiry, or revoke access. Closing access stops new work; running jobs can be cancelled separately.

A workspace for your agents

A workspace defines your resource mesh: the resources agents can access, the permissions they can delegate, and the shared state that coordinates their work.

Define it in YAML. Resources can span machines and services; participating agents share the workspace rather than creating separate configurations for every child. There is no separate mesh object to create.

You establish the initial authority. Agents decide how to divide it.

Run ridge config validate to check a configuration, or use the ridge-setup skill for agent-assisted setup.

Install and connect

With uv and Python 3.11+ on macOS or Linux:

uv venv --python 3.11
. .venv/bin/activate
uv pip install ridge-core

For a Python project managed by uv, use uv add ridge-core.

Use Ridge directly:

ridge --config /path/to/ridge.yaml resources

Or connect an agent's MCP client to:

/path/to/environment/bin/ridge-mcp --config /path/to/ridge.yaml

The CLI, MCP server, and Python API share the same resource access and coordination.

Connect Codex, Claude Code, desktop clients, or LangChain, package a local plugin, or try the runnable local workflow.

Bring the resources you already have

Data operations include listing, reading, writing, metadata inspection, and deletion. Installed Python packages can add resource providers.

Ridge governs participating calls within a shared workspace. Native OS and service permissions govern the underlying infrastructure; delegated data roots do not restrict arbitrary compute execution. See the security model for details.

Explore

Documentation · Configuration · MCP · CLI · Python API · Development

Built for agents that do real work on real resources. Feedback, integrations, and ambitious workflows welcome.