Connecting to Regen AI
[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. 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 | Knowledge and code intelligence | Semantic search across ecosystem documents, code graphs, knowledge graphs, weekly digests |
| Ledger | Blockchain data access | 45+ tools for credits, governance, marketplace, account analytics |
| Registry Review | 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 | Non-technical users, quick knowledge queries | Via API proxy | Instant (use existing) or 5 minutes (create your own) |
| Claude Code | Development, multi-MCP orchestration, complex workflows | Native | 30 seconds (plugins) to 10 minutes (manual) |
| ElizaOS | 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
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
When you ask a question, the GPT calls the KOI API and shows you the tool confirmation before proceeding:
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:
- Go to chatgpt.com/gpts → Create
- Add name, description, instructions, conversation starters
- Click “Create New Action”
- Paste the OpenAPI schema for the API you want to connect
The KOI API schema can be copied from the 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. 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 with all three MCPs:
# 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:
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, Git
- Create a working directory:
mkdir regen-mcps
cd regen-mcps
- Clone the MCP repos
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
- Build the KOI MCP server
# Build regen-koi-mcp
cd ../regen-koi-mcp
npm install
npm run build
# Return to project root
cd ../..
- Enable MCPs in
.claude/settings.json
mkdir -p .claude
cat > .claude/settings.json << 'EOF'
{
"enableAllProjectMcpServers": true
}
EOF
- Add MCP configuration to
.mcp.json
From your regen-mcps directory, run:
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.
- Start Claude Code
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:
- Query KOI for Terrasos methodology documentation
- Query Ledger for BT01 credit batches
- 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:
-
Which connection method fits your workflow—plugins, NPX, or manual config?
-
What would you build with multi-MCP access? Credit research? Governance tools? Something else?
-
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 — Claude Code plugins for all three MCPs
MCP Servers:
- regen-koi-mcp — Knowledge graph access
- regen-python-mcp — Blockchain queries (45+ tools)
- regen-ledger-mcp — Legacy TypeScript access
GPTs:
Eliza:
Documentation:
Week 3 of 12. The forum is the knowledge commons. Discussion here feeds back into KOI.
