Which integrations are available for this server?

Enables retirement of ecocredits via ecoBridge using ETH or ERC-20 tokens on the Ethereum network. Enables retirement of ecocredits via ecoBridge using tokens on the Polygon network.

How do I use Regen Compute?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Regen Compute estimate my session's energy use and show credits I can retire" 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.

Regen Compute

Official

by regen-network

Overview Schema Related Servers Score Discussions

TypeScript

Remote

Regen Compute

Add Regenerative AI to your AI coding assistant in 30 seconds.

npm version License: Apache-2.0 MCP

Every AI session consumes energy. This MCP server lets your AI assistant estimate that footprint and retire verified ecocredits on Regen Network — with immutable on-chain proof.

This is regenerative contribution, not carbon offsetting. No neutrality claims. Just verified funding of ecological regeneration.

Install

claude mcp add -s user regen-compute -- npx regen-compute

That's it. Works immediately — no API keys, no wallet, no configuration needed for read-only tools.

Supported Platforms

Add to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project):

{
  "mcpServers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

Restart Cursor. Tools appear in Cursor's AI chat.

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

Open Windsurf Settings > Cascade > MCP Servers to verify the connection.

Add to .vscode/mcp.json in your workspace:

{
  "servers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

Requires VS Code 1.99+ with GitHub Copilot. Tools are available in Agent mode.

Go to Settings > Tools > AI Assistant > Model Context Protocol (MCP), click +, and paste:

{
  "mcpServers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

Requires a JetBrains AI Assistant subscription.

Add to ~/.gemini/settings.json:

{
  "mcpServers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

Create .continue/mcpServers/regen-compute.yaml in your workspace:

name: Regen Compute
version: 0.0.1
schema: v1
mcpServers:
  - name: regen-compute
    type: stdio
    command: npx
    args:
      - "regen-compute"

Note: MCP tools are only available in Continue's agent mode.

Cody uses the OpenCtx bridge, which requires a local file path (not npx). Install first:

npm install -g regen-compute

Then add to your VS Code settings.json:

{
  "openctx.providers": {
    "https://openctx.org/npm/@openctx/provider-modelcontextprotocol": {
      "nodeCommand": "node",
      "mcp.provider.uri": "file:///ABSOLUTE/PATH/TO/node_modules/regen-compute/dist/index.js"
    }
  }
}

Replace the path with the actual location of the installed package.

Most MCP clients accept this standard config:

{
  "mcpServers": {
    "regen-compute": {
      "command": "npx",
      "args": ["regen-compute"]
    }
  }
}

ChatGPT and OpenAI API: These platforms require a remote HTTP MCP server (streamable HTTP or SSE transport). Regen Compute currently uses stdio transport. HTTP transport support is on the roadmap.

Related MCP server: Jules MCP Server

Quick Start

After installing, ask your AI assistant to run these tools:

estimate_session_footprint — See the energy and CO2 cost of your current session
browse_available_credits — Explore live ecological credits (carbon, biodiversity, marine) on Regen Marketplace
retire_credits — Retire credits to fund regeneration (credit card link by default, or on-chain with a wallet)
get_retirement_certificate — Get a verifiable on-chain proof of your contribution

Or just ask: "Estimate my session's footprint and show me credits I can retire" — the AI handles the rest.

What You Get

Tool	What it does
`estimate_session_footprint`	Estimate energy, CO2, and retirement cost for your AI session
`browse_available_credits`	Browse live sell orders on Regen Marketplace (carbon, biodiversity, marine, species)
`retire_credits`	Retire credits on-chain (with wallet) or get a credit card purchase link (without)
`get_retirement_certificate`	Verify any retirement with on-chain proof
`get_impact_summary`	Regen Network aggregate stats — projects, retirements, jurisdictions
`browse_ecobridge_tokens`	List 50+ tokens across 10+ chains for cross-chain payment
`retire_via_ecobridge`	Pay with USDC/ETH/etc. on Ethereum, Base, Polygon, Arbitrum, and more

Three payment modes — pick what works for you

Credit card (default, no setup) — get a Regen Marketplace link
Direct on-chain — set REGEN_WALLET_MNEMONIC, retire in a single tx
Any token, any chain — USDC on Base, ETH on Arbitrum, etc. via ecoBridge

How It Works

Your AI Assistant (Claude Code / Cursor / etc.)
    │
    │ MCP Protocol (stdio)
    ▼
Regen Compute MCP Server
    │
    ├─ Footprint estimation (heuristic, clearly labeled as approximate)
    ├─ Credit browsing (live sell order data from Regen Ledger)
    ├─ Retirement execution (MsgBuyDirect with auto-retire)
    └─ Certificate retrieval (on-chain verification)
    │
    ▼
Regen Network Ledger (immutable, verifiable, non-reversible)

If anything fails during on-chain retirement, it falls back to a marketplace link. Users are never stuck.

Configuration

Works with zero config. Set environment variables for advanced features:

cp .env.example .env

Variable	Required	What it enables
(none)	—	Footprint estimation, credit browsing, impact stats, marketplace links
`REGEN_WALLET_MNEMONIC`	Optional	Direct on-chain retirement (MsgBuyDirect)
`ECOBRIDGE_EVM_MNEMONIC`	Optional	Cross-chain payment via ecoBridge (send USDC, ETH, etc.)
`ECOBRIDGE_ENABLED=false`	Optional	Disable ecoBridge tools

See .env.example for all options with inline documentation.

Developer Resources

MCP Tools

Tool	Description	Auth required
`estimate_session_footprint`	Estimate AI session energy use and CO2	No
`estimate_monthly_footprint`	Personalized monthly footprint with location/product multipliers	No
`browse_available_credits`	Live sell orders from Regen Marketplace	No
`retire_credits`	Retire ecocredits on-chain or via marketplace link	Wallet
`get_retirement_certificate`	Retrieve on-chain retirement certificate by nodeId or txHash	No
`get_impact_summary`	Regen Network aggregate impact statistics	No
`check_subscription_status`	Subscriber status, cumulative impact, referral link	API key
`get_regen_price`	REGEN/USD price from CoinGecko with cache status	No
`verify_payment`	Verify on-chain payment across 19 chains (16 EVM + BTC + SOL + TRX)	No
`get_community_goals`	Community retirement goals, progress, subscriber count	No
`browse_ecobridge_tokens`*	Cross-chain tokens and prices via ecoBridge	No
`retire_via_ecobridge`*	Retire credits by sending tokens on any EVM chain	EVM wallet

* Requires ECOBRIDGE_ENABLED=true

MCP Prompts

Pre-built workflows you can invoke:

Prompt	Workflow
`offset_my_session`	Estimate footprint → browse credits → retire
`show_regen_impact`	Pull live network stats and summarize
`retire_with_any_token`*	Browse ecoBridge tokens → pick chain/token → retire

* Requires ECOBRIDGE_ENABLED=true

CLI Subcommands

Command	Description
`npx regen-compute`	Start MCP server (stdio transport)
`npx regen-compute serve`	Start the web server (port 3141)
`npx regen-compute pool-run [--dry-run]`	Execute monthly pool retirement batch

REST API Endpoints

All endpoints prefixed with /api/v1/. Protected endpoints require Authorization: Bearer <api_key>.

Endpoint	Method	Auth	Description
`/openapi.json`	GET	No	OpenAPI 3.1 specification
`/payment-info`	GET	No	Payment addresses and pricing tiers
`/confirm-payment`	POST	No	Confirm crypto payment for subscription provisioning
`/retire`	POST	Yes	Retire ecocredits
`/credits`	GET	Yes	Browse available credits
`/footprint`	GET	Yes	Estimate session footprint
`/certificates/:id`	GET	Yes	Get retirement certificate
`/impact`	GET	Yes	Network impact statistics
`/subscription`	GET	Yes	Subscription status and cumulative impact
`/community/goals`	GET	Yes	Community goals, progress, and subscriber stats
`/scheduled-retirements`	GET	Yes	Scheduled retirements with status breakdown

Credit Types

Type	Description
Carbon (C)	Verified carbon removal and avoidance
Biodiversity (BT)	Terrasos voluntary biodiversity credits
Marine Biodiversity (MBS)	Marine ecosystem stewardship
Umbrella Species (USS)	Habitat conservation via umbrella species
Kilo-Sheep-Hour (KSH)	Grazing-based land stewardship

Data Sources

Source	What it provides
Regen Ledger REST	Credit classes, projects, batches, sell orders
Regen Indexer GraphQL	Retirement certificates, marketplace orders, stats
Regen Marketplace	Credit card purchase flow
ecoBridge API	Cross-chain tokens, prices, widget links

Development

Local setup

git clone https://github.com/regen-network/regen-compute.git
cd regen-compute
npm install
cp .env.example .env  # fill in your keys (optional — read-only tools work without)
npm run build

Connect to Claude Code (local build)

Point your MCP config at the local build so changes are reflected immediately:

claude mcp add regen-compute -s user -- node /path/to/regen-compute/dist/index.js

To enable ecoBridge tools locally:

claude mcp add regen-compute -s user \
  --env ECOBRIDGE_ENABLED=true \
  -- node /path/to/regen-compute/dist/index.js

Scripts

Command	What it does
`npm run dev`	Watch mode with hot reload (tsx)
`npm run build`	Production build (tsc)
`npm run typecheck`	Type checking only
`npm test`	Run test suite (vitest)
`npm run test:watch`	Run tests in watch mode

Running tests

npm test              # single run
npm run test:watch    # re-run on file changes

Tests mock all external APIs (RPC providers, ecoBridge, Regen Ledger) — no network calls, no wallets needed.

Roadmap

Phase	Status
1.0 Read-only MCP — footprint, browsing, marketplace links, certificates	Complete
1.5 On-chain retirement — wallet signing, order routing, ecoBridge cross-chain	Complete
2.0 Subscription pool — Stripe, monthly batch retirements, fractional attribution	In progress
3.0 Smart contract — CosmWasm pool, automated retirement, REGEN burn	Planned
4.0 Scale — enterprise API, platform partnerships, credit supply development	Planned

See ROADMAP.md for the full 3-track rollout plan, dependency graph, and business context.

Contributing

We welcome contributions! See CONTRIBUTING.md for the issue workflow, label guide, and branch conventions.

Good first issues: gh issue list --label "good first issue"

License

Apache-2.0 — see LICENSE.

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

21hResponse time

–Release cycle

–Releases (12mo)

Commit activity

Issues opened vs closed

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly
Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
OpenAI
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/regen-network/regen-compute'

If you have feedback or need assistance with the MCP directory API, please join our Discord server