# Connecting to Regen AI

**URL:** <https://forum.regen.network/t/connecting-to-regen-ai/566>\
**Category:** Regen AI\
**Created:** [December 16, 2025, 7:00pm UTC](https://forum.regen.network/t/connecting-to-regen-ai/566 "2025-12-16T19:00:26Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![ygg\_anderson](https://yyz2.discourse-cdn.com/flex004/user_avatar/forum.regen.network/ygg_anderson/32/117_2.png) [@ygg\_anderson](https://forum.regen.network/u/ygg_anderson)\
**Post date:** [December 16, 2025, 7:00pm UTC](https://forum.regen.network/t/connecting-to-regen-ai/566/1 "2025-12-16T19:00:26Z")

</div>

# Connecting to Regen AI

 ![hero](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/92a9bcba4c8dd14211779c377bb4b03a2b76a1d7.jpeg)

# [Week 3/12] Regen AI Update: Connecting to Regen AI - December 16, 2025

- **Posted by:** Shawn Anderson (Gaia AI)
- **Key Focus:** How to connect to Regen’s AI infrastructure across platforms

* * *

Last week we went deep on [KOI—the knowledge layer](https://forum.regen.network/t/regen-koi-mcp-the-knowledge-brain-of-regeneration/561). We traced how documents across the Regen Ecosystem flow through sensors, processors, embedding pipelines, and knowledge graphs to become searchable planetary intelligence. This week is about putting that infrastructure to work. Regen AI currently runs on three MCP servers, each handling different aspects of the ecosystem.

You can connect through Claude Code (the most capable  
option), through GPTs (the most accessible), or through ElizaOS (for autonomous  
agents). Each path has its tradeoffs. In this post we will deep dive into the  
different agentic platforms we use to connect to Regen AI infrastructure and  
discuss why this interoperable, modular approach creates the most surface area  
for regenerative emergence.

* * *

## The Three MCPs

As you know from previous posts, Regen AI consists of three Model Context Protocol servers, each serving a distinct purpose:

| MCP | What It Does | Key Capabilities |
| --- | --- | --- |
| **[KOI](https://github.com/gaiaaiagent/regen-koi-mcp)** | Knowledge and code intelligence | Semantic search across ecosystem documents, code graphs, knowledge graphs, weekly digests |
| **[Ledger](https://github.com/gaiaaiagent/regen-python-mcp)** | Blockchain data access | 45+ tools for credits, governance, marketplace, account analytics |
| **[Registry Review](https://github.com/gaiaaiagent/regen-registry-review-mcp)** | Regen registry project onboarding verification and automation | Document analysis, evidence extraction, cross validation |

**KOI** answers questions about what people have written and built—forum discussions, methodology specs, governance proposals, code architecture. It understands meaning through embeddings and relationships through graph queries.

**Ledger** answers questions about on-chain state—how many credits exist, what’s for sale, who voted on what, what’s in the community pool. It queries the blockchain directly.

**Registry Review** handles document workflows—extracting evidence from PDFs, checking completeness against methodology requirements, generating review reports. It’s currently internal but powers the Registry Review GPT.

These are complementary lenses on the same ecosystem, and the real power emerges when they work together.

* * *

## The Three Platforms

The MCPs are the data layer. To access them, you need a platform that speaks MCP. We use three:

| Platform | Best For | MCP Support | Setup Time |
| --- | --- | --- | --- |
| **[GPTs](https://chatgpt.com/gpts)** | Non-technical users, quick knowledge queries | Via API proxy | Instant (use existing) or 5 minutes (create your own) |
| **[Claude Code](https://docs.anthropic.com/en/docs/claude-code)** | Development, multi-MCP orchestration, complex workflows | Native | 30 seconds (plugins) to 10 minutes (manual) |
| **[ElizaOS](https://github.com/elizaOS/eliza)** | Autonomous agents, social media, scheduled tasks | Via plugin | 10-30 minutes |

**GPTs** are the most accessible—no setup, just open ChatGPT. They access MCP functionality through REST APIs, which means knowledge search works great but blockchain queries aren’t available yet.

**Claude Code** is the most capable—native MCP protocol, parallel subagents, full toolchain. If you’re building or developing, start here.

**ElizaOS** is for autonomy—agents that run on their own, post to social media, respond to community questions without human prompting. Currently on the back burner but functional.

Each platform section below covers connection details, capabilities, and limitations.

* * *

## GPTs: Accessible Agent Interfaces

GPTs are the easiest way for non-developers to access Regen AI. They run in ChatGPT’s familiar interface—no terminal, no configuration, just conversation.

GPTs don’t connect to MCPs directly. Instead, they connect to APIs using the OpenAPI specification. We wrap MCP functionality in REST endpoints, describe them with OpenAPI schemas, and GPTs can then call those endpoints as “actions.”

### The Regen GPTs

**[Regen KOI GPT](https://chatgpt.com/g/g-692f3c6bc5e48191b3d1721f4a8ccdec-regen-koi-gpt)**

 ![koi-gpt-landing-page](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/70ff4ea9ed6a4c4361e74a4bb7dae7a18fd46a16.png)

Searches the KOI knowledge base. Good for:

- Understanding Regen Registry projects
- Staying up to date with the latest news across the ecosystem
- Exploring methodology documentation and impact
- Learning about governance discussions
- Learning about eco credits and the Regen Registry

 ![koi-gpt-governance-search-results](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/b14e18a2cd0de7aee929137969e98b27f51371f6.png)

When you ask a question, the GPT calls the KOI API and shows you the tool confirmation before proceeding:

 ![koi-gpt-tool-call-confirmation](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/acca9f7d04dedc00c4791183f04fec11eaf0ebe3.png)

**Update:** The KOI GPT is now also connected to the Ledger MCP and thus can answer questions directly about on-chain data.

### Creating Your Own Regen GPT

To build a GPT connected to Regen APIs:

1. Go to [chatgpt.com/gpts](https://chatgpt.com/gpts) → Create
2. Add name, description, instructions, conversation starters

 ![koi-gpt-configure-panel](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/e6b9697fbd722c3ebbcd2f4d40811bbc98a99f98.png)

1. Click “Create New Action”
2. Paste the OpenAPI schema for the API you want to connect

 ![koi-gpt-actions-openapi-schema](https://canada1.discourse-cdn.com/flex004/uploads/regen/original/1X/dbb1a9a4c3fd5b58e934bffd58ec715c5e716534.png)

The KOI API schema can be copied from the [Regen KOI GPT](https://chatgpt.com/g/g-692f3c6bc5e48191b3d1721f4a8ccdec-regen-koi-gpt) configuration—click “Explore GPTs,” find Regen KOI GPT, view the configuration, and copy the schema from Actions. API documentation is also available in the [regen-python-mcp repository](https://github.com/gaiaaiagent/regen-python-mcp/blob/main/openapi-combined.json). Once configured, your GPT can query the knowledge graph just like the official Regen KOI GPT.

**Limitation:** GPTs access MCP functionality through HTTP APIs, not the native  
protocol. This means they can’t maintain stateful sessions or orchestrate  
multi-step workflows the way Claude Code can. For knowledge search, this works  
fine. For complex blockchain interactions, you’ll want Claude Code. Another limitation  
of GPTs is that they can connect to a maximum of 30 endpoints per domain. This is currently  
limiting the KOI GPT to not have regen code-base search functionality.

* * *

## Claude Code: Full Power Regen AI

Claude Code is a terminal-based AI agent with native MCP support. It’s the preferred environment for Regen AI development because it combines:

- **Native MCP connectivity** — direct protocol access, not API wrappers
- **Parallel subagents** — spin up multiple workers for complex tasks
- **Built-in tools** — web search, web fetch, bash, file operations
- **Hooks and plugins** — extend functionality without forking
- **Project awareness** — understands codebases, not just individual files

When you ask Claude Code a question that spans knowledge and blockchain data, it can query KOI for context, hit the Ledger for verification, and pull in web results—all in the same response.

### **Option 1: Plugins (Recommended)**

The easiest path. Regen AI publishes a [plugin marketplace](https://github.com/gaiaaiagent/regen-ai-claude) with all three MCPs:

```bash
# Add the marketplace
/plugin marketplace add https://github.com/gaiaaiagent/regen-ai-claude

# Install the plugins you need
/plugin install koi@regen-ai
/plugin install ledger@regen-ai
/plugin install registry-review@regen-ai

# Restart Claude Code, then verify
/mcp

```

Plugins download and configure automatically. No manual setup required.

### **Option 2: NPX (Quick Start)**

If you just want KOI without the full plugin system:

```bash
claude mcp add regen-koi -- npx -y regen-koi-mcp@latest

```

### **Option 3: Manual Configuration**

For full control, clone the repos and configure manually. Choose between project-scoped (MCPs available only in one directory) or global (MCPs available everywhere).

**Prerequisites:** Node.js 20+, Python 3.10+, [uv](https://docs.astral.sh/uv/), Git

1. Create a working directory:

```bash
mkdir regen-mcps
cd regen-mcps

```

1. Clone the MCP repos

```bash
mkdir mcps
git clone <https://github.com/gaiaaiagent/regen-koi-mcp.git> mcps/regen-koi-mcp
git clone <https://github.com/gaiaaiagent/regen-python-mcp.git> mcps/regen-python-mcp

```

1. Build the KOI MCP server

```bash
# Build regen-koi-mcp
cd ../regen-koi-mcp
npm install
npm run build

# Return to project root
cd ../..

```

1. Enable MCPs in `.claude/settings.json`

```bash
mkdir -p .claude
cat > .claude/settings.json << 'EOF'
{
  "enableAllProjectMcpServers": true
}
EOF

```

1. Add MCP configuration to `.mcp.json`

From your `regen-mcps` directory, run:

```bash
cat > .mcp.json << EOF
{
  "mcpServers": {
    "regen-koi": {
      "command": "node",
      "args": ["$(pwd)/mcps/regen-koi-mcp/dist/index.js"],
      "env": {
        "KOI_API_ENDPOINT": "<https://regen.gaiaai.xyz/api/koi>",
        "JENA_ENDPOINT": "<https://regen.gaiaai.xyz/api/koi/fuseki/koi/sparql>"
      }
    },
    "regen-network": {
      "command": "uv",
      "args": [
        "run",
        "--directory",
        "$(pwd)/mcps/regen-python-mcp",
        "python",
        "main.py"
      ],
      "env": {
        "PYTHONPATH": "$(pwd)/mcps/regen-python-mcp/src",
        "REGEN_MCP_LOG_LEVEL": "INFO"
      }
    }
  }
}
EOF

```

Note: The `$(pwd)` will expand to your current working directory, creating absolute paths specific to your system.

1. Start Claude Code

```bash
claude
> /mcp

```

The MCP servers should now be available.For deeper debugging, start Claude Code with `claude --mcp-debug`.

### Example: Multi-Source Query

With KOI and Ledger connected, you can ask compound questions:

> “What methodology does Terrasos use for biodiversity credits, and how many BT01 credits have been issued under it?”

Claude Code will:

1. Query KOI for Terrasos methodology documentation
2. Query Ledger for BT01 credit batches
3. Synthesize a response citing both sources

This is the advantage of native MCP—orchestrating multiple data sources in a single conversational turn.

* * *

## ElizaOS: Autonomous Agents

ElizaOS is an open-source framework for building AI agents that operate autonomously—posting to social media, responding to community questions, executing scheduled tasks.

The framework provides:

- Character definition and personality persistence
- Context management across conversations
- Plugin architecture for custom actions
- Social media integration (Discord, Telegram, Twitter)
- Blockchain wallet connectivity

**Current status:** ElizaOS development is on the back burner while the team focuses on KOI and Registry Review workflows. It remains useful for testing MCP integrations and may return to active development for social agent use cases.

* * *

## What You Can Build

With the MCPs connected, here are workflows that become possible:

**Credit Research**

- Query KOI for methodology documentation
- Query Ledger for issuance data and marketplace prices
- Compare approaches across credit types
- Track project progress from registry to retirement

**Governance Analysis**

- Search KOI for forum discussions around proposals
- Query Ledger for voting records and tally results
- Connect proposals to methodology updates they reference
- Generate evidence-based summaries for community calls

**Developer Workflows**

- Use KOI’s code graph to navigate the regen-ledger codebase
- Query specific modules, keepers, message types
- Understand how credit retirement flows from MsgRetire to state updates
- Find relevant documentation alongside implementation

The pattern across all of these: **multiple data sources, single conversation**. You’re not switching between tools or copy-pasting between windows. The agent handles orchestration while you focus on the question.

* * *

## Discussion

**Questions for the community:**

1. Which connection method fits your workflow—plugins, NPX, or manual config?

2. What would you build with multi-MCP access? Credit research? Governance tools? Something else?

3. For GPT users: what’s missing from the current Regen GPTs?

* * *

## Looking Ahead

Week 4 goes deep on the **Registry Review Agent** —the workflow that transforms manual document reviews into collaborative AI sessions. We’ll cover the 7-stage process, evidence extraction, and how AI handles the mechanical work so reviewers can focus on judgment.

* * *

## Resources

**Plugin Marketplace:**

- [regen-ai-claude](https://github.com/gaiaaiagent/regen-ai-claude) — Claude Code plugins for all three MCPs

**MCP Servers:**

- [regen-koi-mcp](https://github.com/gaiaaiagent/regen-koi-mcp) — Knowledge graph access
- [regen-python-mcp](https://github.com/gaiaaiagent/regen-python-mcp) — Blockchain queries (45+ tools)
- [regen-ledger-mcp](https://github.com/regen-network/mcp) — Legacy TypeScript access

**GPTs:**

- [Regen KOI GPT](https://chatgpt.com/g/g-692f3c6bc5e48191b3d1721f4a8ccdec-regen-koi-gpt)

**Eliza:**

- [Regen Registry Agent](https://github.com/gaiaaiagent/GAIA/tree/regen-assistant-avatar)

**Documentation:**

- [MCP Protocol](https://modelcontextprotocol.io)
- [OpenAPI Specification](https://learn.openapis.org/)
- [Previous Updates](https://forum.regen.network/t/regen-koi-mcp-the-knowledge-brain-of-regeneration/561)

* * *

_Week 3 of 12. The forum is the knowledge commons. Discussion here feeds back into KOI._

---

<div class="post-metadata">

**Author:** ![brawlaphant](https://yyz2.discourse-cdn.com/flex004/user_avatar/forum.regen.network/brawlaphant/32/71_2.png) [@brawlaphant](https://forum.regen.network/u/brawlaphant)\
**Post date:** [December 18, 2025, 2:24am UTC](https://forum.regen.network/t/connecting-to-regen-ai/566/2 "2025-12-18T02:24:04Z")

</div>

This is really shaping up nicely — you can feel the momentum building around making Regen’s tools usable for a much wider audience.

Opening up these AI-integrating components means anyone, from any background or skill level, can start building and contributing to this regenerative economy.

That kind of accessibility is exactly what this niche market needs to truly scale. Excited to see where this goes and how more builders can plug in. 🌱