Forem: Tobiloba Adedeji

I Built a Personal Operating System on Claude Code and Open-Sourced It

Tobiloba Adedeji — Tue, 07 Apr 2026 15:17:22 +0000

I didn't set out to build an operating system. I set out to apply for jobs.

I was using Claude Code, and I needed it to scan job boards, score listings against my profile, tailor my CV per role, and track what I'd applied to. I got that working. Then I needed email triage. Then article writing in my voice. Then workout tracking, finance logging, message aggregation across Telegram and Discord and WhatsApp.

Each piece worked. But every new Claude Code session started blank. The job pipeline I spent an hour building? Evaporated when the session ended. The writing samples I fed it? Gone. I was rebuilding the same context over and over, and it was driving me insane.

The fix was obvious in hindsight: stop treating the AI like a conversation and start treating it like a runtime. Give it persistent state. Give it a filesystem. Give it scripts it can call. Give it a configuration file that tells it who I am and what I care about.

Once I did that, I had an operating system.

I called it Super Tobi. It's open source now.

What makes it an OS and not a prompt collection

A prompt collection is what you get when you save your best ChatGPT conversations. It's stateless. It doesn't remember that you applied to Anthropic last Tuesday or that your girlfriend's birthday is in three days.

An operating system manages state, runs processes, schedules work, and enforces boundaries between things. That's what Super Tobi does:

CLAUDE.md is the kernel — a specification file that tells Claude who I am, what I'm building toward, what voice to write in, and what rules to follow. When I edit this file, the entire system's behavior changes. It's not a prompt. It's a config.

.claude/commands/ is the CLI — 19 markdown files that each define a complete system behavior. /daily-sync compiles a morning briefing from 8 data files. /war-plan calculates my job application conversion rate and tells me what to do today. These aren't prompts either — they're specs with data flows and error handling.

scripts/ are the daemons — 23 Python programs that do work Claude can't do alone. job_hunter.py scrapes career pages and fetches job descriptions. resume_tailor.py extracts ATS keywords and rewrites my CV. analytics.py calculates funnel metrics. They run on cron, get called by commands, or run standalone.

data/ is the filesystem — JSON for structured data, markdown for text, append-only for logs. No database. Every piece of state is a file that Claude can read, write, and reason about.

I wrote a longer argument for why agent coordination is fundamentally an OS problem in a separate piece. The short version: when multi-agent systems fail, the failure is almost never intelligence. It's the handoff between agents, the shared state, the scheduling — problems that operating systems solved for programs in the 1960s. Super Tobi is me applying that insight to my own life.

The commands I run every day

`/daily-sync`

I type this every morning and get a single compiled view of my life. Not a chatbot response — a dashboard assembled from real files:

My girlfriend's birthday coming up in 2 days, with a draft message already written. YC deadline in 27 days, application 60% done. Career pipeline: 34 applied, 8 responded, 3 interviews, with 2 follow-ups I'm late on (Helius and Anza). Learning: day 14 of system design, 8-day streak, today's topic is distributed caching. Workout: upper body push day. This week's spending: ₦42,300, broken down by category.

I've used a lot of productivity tools. Notion, Todoist, Google Calendar, various habit trackers. None of them talk to each other. /daily-sync pulls from all of them (well, from the files that represent them) into one view. That's the thing I can't go back from.

`/apply jobs` and the resume tailor

I'M ACTUALLY PROUD OF THIS ONE.

resume_tailor.py takes a job description, extracts keywords across five domains (AI/ML, blockchain, backend, frontend, devrel), scores my current resume against the JD, then rewrites it to maximize ATS compatibility. Not generically — per job, using the actual keywords from that specific listing.

I ran it against an Anthropic ML Engineer posting. My base resume scored 38%. After tailoring: 84%. The script had reordered my experience sections, woven in keywords like "MLOps" and "distributed systems" where they fit naturally, quantified my achievements, and switched my title from "AI Researcher" to "ML Engineer" to match their language.

Then /analytics shows me the funnel: how many jobs discovered, how many applied, response rate, interview conversion. Right now I'm at 23% response rate and 8.8% interview rate across 34 applications. Having those numbers changes how you think about job searching — it stops being an emotional rollercoaster and starts being a pipeline you can optimize.

`/write`

OK this is the meta one — I used this system to draft parts of this post (I'm being upfront about that). It reads my actual writing samples from DEV, Substack, and Twitter, and it tries to match my patterns. It knows about the ALL CAPS thing when I'm excited. It knows I do parenthetical tangents (like this one right here). It knows "delve" is banned.

The output needs editing. Always. But it's my voice that needs tightening, not generic AI voice that needs a personality transplant.

`/outreach` and `/interview-prep`

These are new. /outreach generates personalized cold emails and LinkedIn DMs by reading the company research I've stored in data/career/intel/. /interview-prep pulls the actual JD and company intel, generates role-specific questions, and runs mock interview sessions with coaching on my answers.

Why files instead of a database

I tried Supabase first. Spent two days on it. Then realized something that should have been obvious: Claude Code can't query Supabase. But it can read a JSON file. It can write markdown. It can grep through a folder.

The filesystem isn't a workaround — it's the correct abstraction for this problem. Claude already knows how to navigate files. Every programming language has file I/O. git gives you version control for free. And for a personal system with hundreds of files (not millions), there's no performance argument for a database.

There's also a readability argument. I can open data/career/jobs/applications.json in any text editor and see exactly what the system knows about my job search. Try doing that with a Postgres table from your phone.

How commands compose into a pipeline

The thing that separates a system from a collection of tools is that every command reads from and writes to the same filesystem:

/apply jobs
  → job_hunter.py scans career pages, stores JDs in data/career/jobs/

/analytics
  → reads data/career/jobs/
  → calculates funnel: discovered → applied → responded → interview

/apply jobs --tailor
  → resume_tailor.py reads the stored JD
  → extracts ATS keywords, generates tailored resume
  → saves to data/career/resume/tailored/

/outreach
  → reads data/career/intel/ for company research
  → generates personalized messages, tracks what's sent

/interview-prep
  → reads JD + intel + tailored resume
  → generates questions, runs mock sessions

/follow-up
  → scans all applications for overdue follow-ups
  → drafts emails, logs everything

No orchestration framework. No message queue. Each command is independent but they share the filesystem. Unix philosophy applied to a life OS: small tools that do one thing, connected by a common data layer.

Fork it and make your own

git clone https://github.com/tobySolutions/super-tobi.git my-os
cd my-os

python3 -m venv .venv
source .venv/bin/activate
pip install rich httpx requests playwright

# 1. Edit CLAUDE.md — replace my identity with yours
# 2. Edit config/settings.yaml
# 3. cp config/api_keys.env.example config/api_keys.env
# 4. Create life_systems_map_v1.md from the template
# 5. Open Claude Code. Type /status.

Step 1 is the only one that really matters. CLAUDE.md defines everything — your identity, your goals, your voice, your rules. The scripts and commands are generic enough to work for anyone. The kernel is what makes it yours.

The gap nobody's filling

Most people use AI the way people used computers before operating systems — one task at a time, start from scratch each session, no persistent state, no background processes.

Developers have figured out how to build real AI systems: multi-step pipelines with state management, error handling, scheduled runs. But that requires you to be a developer, and even then it's fragile custom scripts held together with hope.

There's a version of this that's packaged properly — with a filesystem abstraction, managed processes, a permission model, a UI for non-developers. I think that's a massive product opportunity and I have some notes on it if you're interested.

But Super Tobi is the version you can fork today.

github.com/tobySolutions/super-tobi

Agent Architectures: A Map

Tobiloba Adedeji — Thu, 26 Feb 2026 16:25:27 +0000

Last year I was tasked with building an "agentic pet": a Pudgy Penguin that could talk, react, and feel alive. I slapped an LLM on Vercel's AI SDK and built a chat UI with tool calls wired up. Then someone asked if the penguin could remember things between sessions, if it could react to events on its own, if its health could change in real-time. Each question implied different infrastructure: a persistent store, an event loop, a process supervisor. I hadn't thought about any of it. I'd been building a chatbot and calling it an agent, and the word had hidden every decision that actually mattered.

Below is a map of four architectures you might actually mean when you say "agent," and why you should sort that out before you write any code.

The Map

Four structural modes, classified by two questions about runtime behavior: who initiates action, and when does the process end?

These two axes are useful because they determine your infrastructure, at least most of the time. Do you need a server or a cron job? A persistent store or a disposable context?

Mode	Who initiates	When it ends	Infrastructure shape
Copilot	Human, every turn	When the human stops	Request-response server, session-scoped context, no persistence
Daemon	Human once, then events	Runs until killed or crashes	Long-running process, persistent state, crash recovery, observability
Subagent	Parent process	When the scoped task completes	Parent-managed lifecycle, scoped context, no independent recovery
Workflow	Orchestrator script	When the sequence finishes	Fixed pipeline, LLM as a step, no adaptive control flow

Copilot

The human initiates every turn, whether single-shot or multi-turn, and the system never acts unprompted. There is no lifecycle beyond the conversation. Close the tab and nothing is running.

ChatGPT in conversation mode, GitHub Copilot, Claude AI, and Claude Code in interactive mode are all copilots.

In practice this means a request-response server and session-scoped context. You can skip persistent storage; nothing has to survive past the tab. If it crashes, the user just asks again, though they'll get annoyed if that happens too often.

Daemon

A persistent background process that stays alive between events or triggers, acts on them, and goes back to idle. The human kicks it off once (sets it up, points it at a channel or a log stream) and after that, it runs on its own.

Crash recovery is most obviously a problem in this mode. A daemon that loses its memory between restarts is broken. You also need to think about supervision (what happens when it dies at 3 AM?), event ingestion (webhooks, queues, polling), and observability for a process that runs unattended.

A Slack bot that wakes on mentions, a monitoring agent polling logs, a customer support agent that remembers prior conversations, OpenClaw heartbeat.md / cron, Codex running async tasks; these are all daemons.

A daemon needs a long-lived server or worker with persistent storage for state and memory. You also need a supervision strategy, plus logging and alerting so you know when it falls over, and you'll probably burn a few nights discovering which failures you forgot to instrument.

Subagent

Like a Unix process: it can be short-lived or long-running, you can communicate with it while active, but it has no lifecycle beyond the parent that created it. When the task is done, it terminates.

A subagent usually has no persistent memory and no awareness of its siblings. It reads what it's given, does the work, hands back a result, and exits. Need the same work again? Spawn a fresh one. Retry logic, failure handling, all of that lives in the parent.

Claude Code's Task tool, OpenAI Agents SDK handoffs, or a micro-service that spins up an LLM worker for a scoped job all fit this pattern.

You'll need a parent process that manages spawn and termination, plus scoped context (only what the subagent needs for its task). Any shared state should go through the filesystem or a database, not through conversation.

Streaming is where this gets ugly. Picture subagents running in parallel: one fetching docs, another analyzing code, a third running tests, all producing output at their own pace. The first time I tried this, the UI turned into a slot machine. You need to funnel all of it back through a single UI coherently, nested inside a parent stream, displayed to one user staring at one screen. That's the UX engineering problem most frameworks don't address.

Workflow

A scripted sequence of steps where one or more involve an LLM call. You define the sequence in code as a DAG, a pipeline, or a chain of function calls; it executes in order and is fully specified before it starts.

This works best when you know the steps in advance. The value is reliable orchestration across time, not adaptive decision-making; when people try to cram a constantly-changing process into a fixed workflow, it gets ugly fast.

You can't keep a script in memory for three days. You need to pause, persist state to disk or database, survive process restarts, and resume exactly where you left off. Before we used anything like Temporal or Inngest, we kept discovering half-finished runs after a deploy and had no idea what the system had already done. That's the niche those tools and Trigger.dev occupy: durable execution across long time spans with async human behavior in the loop.

Hybrids

Hybrids exist, and they make the taxonomy useful rather than invalidating it, because they show how the modes interact in real systems.

Claude Code spans three modes in a single session. In interactive mode, it is a copilot: you type, it responds. Its Task tool spawns subagents that execute a scoped job and terminate. In agent mode, it takes multiple autonomous actions in sequence. Ask it to refactor authentication and it reads files, spawns an exploration subagent, edits twelve files, runs tests. Three modes, one session, each with its own way of failing, consuming resources, and exposing an interface. The taxonomy tells you which mode you are in at any given moment.

A note on frameworks

Agent frameworks tend to emphasize character-like setups (a role, some backstory, a set of goals). They give comparatively little guidance on how the thing actually runs or what it persists. CrewAI is the clearest example. LangGraph and AutoGen follow the same pattern: they focus on agent identity and mostly ignore runtime shape. You end up configuring a "Senior Research Analyst" with a backstory and a delegation strategy before you've even decided whether the system needs a persistent store, and the architecture requirements hide behind the character sheet.

Close

Most people use "agent" as a loose marketing term that tells you almost nothing about the actual architecture.

If you find yourself reaching for the word, force yourself to write down the concrete runtime you actually need: who starts it, how it dies, and what must survive in between. The right infrastructure usually falls out of those three answers.

MCP-Powered Agents: Wiring Gaia to ACI Tools

Tobiloba Adedeji — Fri, 05 Sep 2025 10:17:06 +0000

Most AI demos stop at text. In production, your agent should do things—like starring a repo, creating issues, or labeling PRs—safely, with audit trails and least-privilege access.

This guide shows an end-to-end setup where a Gaia-hosted LLM proposes a tool call and ACI.dev executes it against GitHub on the user’s behalf.

// Detect dark theme var iframe = document.getElementById('tweet-1957763448516862463-563'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1957763448516862463&theme=dark" }

What you’ll build

An agent request like: “Star tobySolutions/stream2peer.”
The model returns a structured tool call (function name + JSON args).
Your server executes it via ACI SDK using the user’s linked GitHub account.
You get a clean, auditable result.

Architecture

Prerequisites

Python 3.10+
Gaia API key and domain (OpenAI-compatible)
Gaia toolkit: https://www.npmjs.com/package/gaia-toolkit
ACI.dev account with:
- A project and default agent
- GITHUB app configured
- Linked GitHub account (via OAuth)
- Agent allowed apps includes GITHUB
- Agent API key (for ACI SDK)

Make sure to use the Gaia toolkit to start and run your Gaia nodes locally.

One-time ACI platform setup

Create/enter project & agent → platform.aci.dev
Configure GITHUB app → App Store → GITHUB → Configure App
Link GitHub account → App Configurations → GITHUB → Add Account → Start OAuth2 Flow Choose a **linked account owner id* (e.g., tobySolutions). You’ll use this in code.
Allow agent to use GITHUB → Project Settings → Manage Project → Agent → Edit → ALLOWED APPS: GITHUB
Copy the agent API key

Environment

Create .env in your project root:

# Gaia
GAIA_BASE_URL=https://YOUR-GAIA-DOMAIN/v1
GAIA_API_KEY=your_gaia_api_key

# ACI
ACI_API_KEY=your_aci_agent_api_key
ACI_OWNER_ID=   # your linked account owner id chosen during OAuth link

Install dependencies

# pip
pip install --upgrade pip
pip install openai python-dotenv aci

# or with uv
uv pip install openai python-dotenv aci

Some environments publish the package as aci (not aci-sdk). Use Python 3.10+.

Minimal working example

Goal: Tell the model the GITHUB “star repo” function exists, let it propose a tool call, then execute it via ACI.

# main.py
import os, json
from dotenv import load_dotenv
from openai import OpenAI
from aci import ACI

load_dotenv()

# --- Clients ---
llm = OpenAI(
    base_url=os.getenv("GAIA_BASE_URL"),      # Gaia’s OpenAI-compatible endpoint
    api_key=os.getenv("GAIA_API_KEY"),
)
aci = ACI()                                   # uses ACI_API_KEY from .env

OWNER_ID = os.getenv("ACI_OWNER_ID")          # linked account owner id

def main() -> None:
    # 1) Discover the function schema from ACI
    github_star_repo_fn = aci.functions.get_definition("GITHUB__STAR_REPOSITORY")

    # 2) Ask the model to do the task, including the tool schema
    resp = llm.chat.completions.create(
        model="Llama-3-Groq-8B-Tool",         # pick a tool-capable model available on your Gaia node
        messages=[
            {"role": "system", "content": "You are a helpful assistant with access to tools."},
            {"role": "user", "content": "Star the tobySolutions/stream2peer GitHub repository for me."},
        ],
        tools=[github_star_repo_fn],
        tool_choice="required",               # force a demo tool call; drop in prod
    )

    msg = resp.choices[0].message
    tool_call = msg.tool_calls[0] if msg.tool_calls else None
    if not tool_call:
        print("Model replied with text only:", msg.content)
        return

    # 3) Execute the function via ACI (server-side, with your credentials)
    args = json.loads(tool_call.function.arguments or "{}")
    # Optional guardrail: only allow your org
    if args.get("owner") != "tobySolutions":
        raise ValueError("Blocked: only allowed to act for owner=tobySolutions")

    result = aci.handle_function_call(
        tool_call.function.name,              # "GITHUB__STAR_REPOSITORY"
        args,                                 # {"owner": "...", "repo": "..."}
        linked_account_owner_id=OWNER_ID,
    )
    print("ACI result:", result)

if __name__ == "__main__":
    main()

Run it:

python main.py

Expected flow:

LLM returns a tool call like:

   `{"name":"GITHUB__STAR_REPOSITORY","arguments":     {"owner":"tobySolutions","repo":"stream2peer"}}`

Your server calls aci.handle_function_call(...) with your linked account owner id.
GitHub stars the repository; you see a success payload.

Why this pattern works

Discover: Fetch the exact function schema from ACI; pass it to the model.
Constrain: The model can only call what you expose.
Execute: Your backend holds credentials; the model never sees tokens.
Audit: You can log every call and enforce org/repo allowlists.

Extending beyond “star repo”

Discover more ACI functions and expose them to the model:

issue_create = aci.functions.get_definition("GITHUB__CREATE_ISSUE")
comment_pr  = aci.functions.get_definition("GITHUB__COMMENT_ON_PR")

tools = [github_star_repo_fn, issue_create, comment_pr]
resp = llm.chat.completions.create(
  model="Llama-3-Groq-8B-Tool",
  messages=[...],
  tools=tools,
  tool_choice="auto",
)

Your server logic remains the same—just route the selected tool call to aci.handle_function_call(...).

Troubleshooting

No tool call generated
Ensure the function schema is in tools=[...]. For demos, keep tool_choice="required".
Permission errors
Confirm: GITHUB app configured, GitHub account linked, agent allowed to use GITHUB.
Wrong owner
The linked_account_owner_id must match the id you chose during account linking (e.g., tobySolutions).
Package install issues
Use aci (not aci-sdk) and Python 3.10+. Upgrade pip if needed.

MCP note

If you’re building an MCP stack, expose ACI tools via an MCP server so any MCP-aware client (including ones running against Gaia) can discover and call them. The execution layer—ACI—stays the same.

Wrap-up

You now have a clean pattern to turn LLM intent into real actions using Gaia for inference and ACI.dev for tool execution.
Swap the function, keep the shape, and your agent can open issues, label PRs, or post to Slack—safely and audibly.

Building an AI-Powered Minecraft Agent with Gaia

Tobiloba Adedeji — Tue, 02 Sep 2025 09:22:39 +0000

Minecraft has always been a sandbox for creativity. But what if you could have an AI teammate inside your world—able to chat, mine, build, and follow your instructions in natural language?

That’s exactly what I built using Gaia’s decentralized AI, LangChain, and mineflayer.

// Detect dark theme var iframe = document.getElementById('tweet-1929930385535726024-105'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1929930385535726024&theme=dark" }

The In-Game Assistant Challenge

Minecraft bots aren’t new, but they’re often:

Scripted → Hardcoded to do specific tasks, not flexible.
Centralized → Dependent on APIs like OpenAI, costly and limiting.
Rigid → Only respond to strict commands, no conversational flow.

I wanted something better:

A bot that understands natural language.
Powered by decentralized AI (Gaia).
Flexible enough to mine, build, follow, and adapt to tasks.

Solution: Gaia + LangChain + Mineflayer

The solution combines three technologies:

mineflayer → the library that lets you control Minecraft bots programmatically.
LangChain → an agent framework that allows tool-calling.
Gaia → decentralized LLMs running on open infrastructure.
Gaia toolkit → https://www.npmjs.com/package/gaia-toolkit

Together, they enable a smart Minecraft companion.

Architecture: From Chat to Action

Here’s the high-level design:

Player messages → sent in chat.
Bot → listens and processes input.
LangChain agent → decides which action/tool to execute.
Gaia node → provides LLM reasoning.
Mineflayer → carries out the command in Minecraft.

Bot Setup

First, spin up the Minecraft bot and connect to your server:

import { createBot } from "mineflayer";
import { pathfinder } from "mineflayer-pathfinder";

const bot = createBot({
  host: "localhost",
  port: 25565,
  username: "Gaiabot",
});

bot.loadPlugin(pathfinder);

bot.once("spawn", () => {
  console.log("Gaiabot ready.");
  bot.chat("Hello! I'm online and ready to help with Minecraft tasks!");
});

✅ This ensures the bot logs into your server and greets you when it’s ready.

LLM Integration with Gaia

Next, connect the bot to a Gaia domain node. This provides decentralized inference using Meta Llama-3.1.

import { ChatOpenAI } from "@langchain/openai";

const model = new ChatOpenAI({
  model: "Meta-Llama-3.1-8B-Instruct-Q5_K_M",
  configuration: {
    apiKey: process.env.GAIA_API_KEY,
    baseURL: "https://node_id.gaia.domains/v1",
  },
  temperature: 0.3,
});

With this setup, you’re running on Gaia’s decentralized network, not a centralized API.

It is recommended that you also run a node locally and use it with your agent directly - Gaia toolkit works perfectly here.

Dynamic Tools: Giving the Bot Superpowers

The core innovation is the tool system. Tools are structured actions the AI can call. For example, here’s the mining tool:

new DynamicTool({
  name: "mine_block",
  description: "Mine a specific type of block near the bot",
  func: async (blockType: string) => {
    const block = bot.findBlock({
      matching: (blk: any) => blk.name.includes(blockType.toLowerCase()),
      maxDistance: 32,
    });

    if (!block) return `No ${blockType} found nearby.`;

    await (bot as any).collectBlock.collect(block);
    return `Mined ${block.name} at ${block.position}`;
  },
});

Other tools include:

place_block → place blocks from inventory.
follow_player → follow a player around.
go_to_player → walk to a player’s position.
check_inventory → list what’s in the bot’s inventory.
stop_movement → halt all actions.

✅ Tools map natural language → structured actions → in-game results.

Handling Player Chat Commands

Some commands bypass the AI for instant execution:

bot.on("chat", async (username, message) => {
  if (message === "!inventory") {
    const items = bot.inventory
      .items()
      .map((i: any) => `${i.name} x${i.count}`)
      .join(", ");
    return bot.chat(items || "I have nothing right now.");
  }

  if (message === "!stop") {
    bot.pathfinder.setGoal(null);
    return bot.chat("Stopped all movement.");
  }
});

✅ This makes the bot responsive for common tasks while still allowing AI reasoning for more complex ones.

AI in Action

When a player sends a free-form request, the bot routes it through Gaia + LangChain:

const response = await chain.invoke({
  input: `Player ${username} says: ${message}`,
});

bot.chat(response.output.slice(0, 100)); // keep short for chat

Example interaction:

Player: Can you mine some coal?
Bot: Looking for coal to mine...
Bot: Successfully mined coal at (23, 65, -110).

✅ The bot thinks, acts, and reports back naturally.

User Experience Design

Several small design details improve the experience:

Thinking feedback → Bot says “Let me help you with that…” before acting.
Error handling → Fallback responses if a tool fails.
Short replies → Truncated answers to fit Minecraft chat.
Graceful shutdown → Safe disconnect on SIGINT.

These touches make the bot feel less like a script and more like a companion.

Real-World Use Cases

Survival helper → Automate mining, building, and farming.
Learning companion → Teach new players basic tasks.
Server assistant → Handle repetitive chores.
AI experiments → Extend tools for crafting, farming, or multiplayer collaboration.

Deployment & Configuration

Clone the repo:

   git clone https://github.com/GaiaNet-AI/gaia-cookbook
   cd javascript-typescript/minecraft-gaia-agent

Install dependencies:

   npm install

Add your Gaia API key in .env:

   GAIA_API_KEY=your_key_here

Start a Minecraft server (local or hosted).
Run the bot:

   npm start

Jump in-game and start chatting with your AI teammate 🎮

Why Gaia’s Decentralized Approach Matters

Traditional AI bots rely on closed APIs. Gaia’s decentralized LLMs give:

Freedom → no reliance on OpenAI or other providers.
Customization → swap in different Gaia domains and models.
Community scaling → open-source, extensible, and composable.

For Minecraft, this means developers can create smarter bots without lock-in.

Future Enhancements

Crafting recipes → AI learns how to craft items.
Multi-agent collaboration → multiple bots cooperating.
On-chain connections → link Minecraft events to blockchain actions.
Educational use → AI tutors inside Minecraft servers.

Conclusion: More Than a Minecraft Mod

The Minecraft Gaia Agent is more than just a fun experiment. It’s a blueprint for AI companions in games, simulations, and beyond.

By combining Gaia’s decentralized AI, LangChain’s tool-calling, and mineflayer’s Minecraft API, we created a bot that can understand, act, and evolve.

👉 Explore the repo: Minecraft Gaia Agent
👉 Learn more about Gaia: GaiaNet.ai

YES! Decentralized AI agents with MCP support are a thing.

Tobiloba Adedeji — Tue, 10 Jun 2025 12:33:50 +0000

Tobiloba Adedeji

May 28 '25

Run a decentralized MCP application with Gaia

#ai #web3 #mcp #webdev

Comments

7 min read

Run a decentralized MCP application with Gaia

Tobiloba Adedeji — Wed, 28 May 2025 11:54:42 +0000

Decentralized AI is becoming a reality, allowing developers to run powerful AI agents on their own hardware and extend them with live data.

In this guide, we’ll show you how to run a decentralized application using a Gaia node with MCP (Model Context Protocol) – specifically, we’ll wire up a Gaia AI agent to a weather service. We’ll explain the basics of Gaia and MCP, walk through setting up a Gaia node with MCP support, configure a weather MCP server (using OpenWeather data), and then launch everything to get real-time weather responses from your AI.

By the end, you’ll have a local AI agent that can fetch live weather info on command – all using decentralized, open-source tech.

Preview tweet below:

// Detect dark theme var iframe = document.getElementById('tweet-1922410546386567683-390'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1922410546386567683&theme=dark" }

What Are Gaia and MCP? (And Why Decentralization Matters)

Gaia is a decentralized computing infrastructure that lets anyone deploy and run their own AI agent node.

Think of a Gaia node as your personal AI assistant running on your machine (or in the cloud) – it comes with a fine-tuned language model, optional private knowledge base, and a web/chat API. Gaia nodes can even serve as drop-in replacements for OpenAI’s API. Because each node is self-hosted and networked, Gaia enables an open, decentralized AI network where individuals control their AI’s data, behavior, and how it serves others, rather than relying on a centralized provider.

MCP (Model Context Protocol) is an emerging open standard for connecting AI models to external tools and data. Introduced by Anthropic in late 2024, MCP acts like a “USB-C for AI” – one universal interface for many integrations. It’s a bi-directional, stateful protocol that allows an AI (or its host application) to call out to external services in a standardized way. Each external capability is provided by an MCP server advertising certain “tools” or functions it can perform (for example: fetch weather data, run a database query, etc.). The AI’s host (in our case, the Gaia node) includes an MCP client that knows how to communicate with these servers. Instead of writing custom code for every API an AI might use, MCP lets us plug in new tools as easily as plugging in a device – greatly simplifying and standardizing AI integrations.

Why is decentralization important here? In a traditional setup, if your AI needs real-time info (weather, stock prices, etc.), you might rely on a specific platform’s plugins or API calls, often tied to a single company’s ecosystem. With Gaia and MCP, everything is open and configurable. You run the AI node, you choose or run the MCP servers for tools, and you aren’t locked into one vendor’s infrastructure. This means more control, privacy, and innovation – anyone can create new MCP-compliant tools and any AI client can use them.

Gaia’s vision is often described as “YouTube for knowledge and skills” where individuals can deploy and monetize AI agents with their own expertise. By leveraging MCP, those agents can safely access live data or perform actions without hardcoding each integration. Decentralized applications built on Gaia + MCP empower developers to create rich AI services that they fully own and control, while tapping into a growing ecosystem of open tools.

Setting Up Gaia with MCP Support

First, let’s get a Gaia node up and running on your machine. The experimental Gaia node version we’ll use includes built-in MCP client support, which allows it to communicate with MCP servers. (Make sure you have a GPU or Apple Silicon machine that meets the requirements – Gaia runs a local large language model. See Gaia’s docs for system requirements.)

1. Install (or update) the Gaia node software: If you haven’t installed Gaia before, the easiest way is via the official install script. Run this in your terminal (macOS/Linux or WSL on Windows):

curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash

The above command downloads and runs Gaia’s installer script. It will fetch the latest GaiaNet node release and set up the gaianet CLI tool. If you already have Gaia installed, you can run the same command to update to the latest version. After installation, make sure to add Gaia to your PATH as instructed (the installer prints a source ... command; run that or add it to your shell profile).

2. Initialize your Gaia node: Once the CLI is installed, initialize the node with default settings:

gaianet init

On first run, this will download a default LLM model (which can be several GB, so be patient) and set up a configuration file in ~/gaianet/config.json. By default, Gaia uses a fine-tuned Llama 3.2 model and a small knowledge base (e.g. about Paris) to start. You can later customize the model or knowledge, but for now the default is fine.

3. Verify MCP client support: The latest Gaia versions (v0.4.27+ as of 2025) include MCP client functionality. There isn’t a separate installation for MCP – it’s built into the node. However, it may be disabled by default until configured. With the installation run above, you will have an mcp_config.toml file.

Configuring the Weather MCP Server (mcp_config.toml)

We want our Gaia node to use a weather service via MCP. To do that, we must tell Gaia’s MCP client how to connect to a weather MCP server. Gaia looks for an MCP configuration file (let’s call it mcp_config.toml) which lists available MCP servers and how to launch or reach them.

Go to your Gaia config directory (likely ~/gaianet/ in your home folder) and open a file named mcp_config.toml.

You can use the command below to open the file:

nano mcp_config.toml

Open this file in a text editor and add only the following:

[[mcp.server]]
name   = "gaia-weather"
enable = true
host   = "127.0.0.1"
port   = 8002

Let’s break down what this does:

The [mcp] section enables MCP support and allows auto-starting servers. “Auto-start” means Gaia will launch the MCP server process on demand (when the AI needs it) instead of expecting it to already be running. This is convenient for local tools.
Under [[mcp.servers]], we define one server configuration (the double brackets denote an array of server entries in TOML). Here we name it "weather" – this is the tool name our AI will use to refer to the weather service.
We provide the command to start the server. This could be a path to an executable or a script. We’ll set up this mcp-weather command soon (it will be the Weather MCP server).

How to get your OpenWeather API key: If you don’t have one, you can get a free API key from OpenWeather.

Just sign up on their site – once you register, they’ll send you an API key (APPID) via email or your account page. The free tier lets you make a good number of weather queries for personal use. Copy that key and paste it in the config above in place of <YOUR_OPENWEATHER_API_KEY>.

Now that Gaia is configured to know about a "weather" tool and how to launch the server for it, we need to actually install or build that server.

Now you can then configure the env key for your MCP server with the below command:

export OPENWEATHERMAP_API_KEY=Your_KEY

Then, after the above, you can run the server with the command below:

gaia-weather-mcp-server-sse

Launching Gaia and Getting Weather Responses

Start the Gaia node and see it interact with the weather MCP service.

1. Start (or restart) your Gaia node: If this is a fresh setup, just run:

gaianet start

If your node was already running from earlier, stop it (Ctrl+C or gaianet stop) and start it again to load the new MCP config. When Gaia starts, it will initialize the AI model and related services. A successful start will print a message with a local or public URL where you can access the Gaia node’s web interface. It typically looks like Node is live at: https://<random-subdomain>.gaia.domains along with a local URL (http://localhost: etc.).

2. Open the Gaia chat UI: Visit the URL printed by the start command in your browser. You should see a web chat interface for your Gaia node (a simple chatbot UI). This UI lets you chat with the AI agent directly.

3. Ask a weather question: In the chat, try typing something like:

“What’s the weather like in **New York City* right now?”*

When you send this, the Gaia node’s LLM will process your request. Because we’ve enabled the weather tool, the AI has the option to use it. Under the hood, one of two things will happen:

Ideally, the model recognizes this query is asking for current weather, and (thanks to Gaia’s function-calling setup) it will produce a structured response indicating it wants to use the weather tool. For example, the model might generate a JSON like: {"tool": "weather", "params": {"city": "New York City"}} (the exact format can vary, but the idea is it requests the weather tool for New York City). Gaia’s MCP client sees this and springs into action.
Gaia’s MCP client receives the data and provides it to the LLM as context. The LLM then generates a final answer for you.

After a short moment, you should see the AI respond with the live weather info. For example, it might say:

“Currently, in New York City it’s 27°C with clear skies.”

Your AI agent just pulled real-time data from an external API in a decentralized manner! The key point is that no centralized service (like ChatGPT plugins or a third-party bot) was involved – your Gaia node ran the query through a tool you set up yourself. The entire flow was enabled by the open MCP standard.

Wrapping Up: The Potential of Gaia + MCP

In this tutorial, we successfully connected a Gaia decentralized AI node with a live weather service using MCP – creating a proof-of-concept decentralized application. This simple weather bot demo showcases a much larger idea: with protocols like MCP, AI agents can be modular and extensible, pulling in real-time data or performing actions, all while you retain control. Gaia provided the backbone – a self-hosted AI agent – and MCP provided the bridge to external knowledge.

The potential here is huge. You could similarly plug in an MCP server for stock market data, home IoT device control, database queries, or any custom tool. As the MCP ecosystem grows (with many open-source servers available for everything from GitHub issues to Spotify control), your Gaia node can become a hub of decentralized intelligence, combining your personal or community knowledge base with worldwide real-time information. Because it’s decentralized, you are not dependent on any single cloud service or vendor approvals – you mix and match tools freely. It’s the spirit of the open web, brought to AI: anyone can build and share a tool, and any AI agent can use it.

As more developers experiment with Gaia and MCP, we may see autonomous agent networks that coordinate via standardized protocols, marketplaces of MCP services, and personal AI agents that truly become “plug-and-play” with new skills.

Build a personal PR-reviewer with Gaia, Langchain, and Next.js.

Tobiloba Adedeji — Wed, 21 May 2025 10:15:42 +0000

The wave of AI agents nowadays has made some major software development procedures and processes more susceptible to automation.

Think Model Context Protocol (MCP), tool-calling, and agentic frameworks capable of bringing any software for use with any Large Language Model (LLM) via API calls in a backend server with some additional parsing logic for response cleaning and the presentation of external data in a way that most LLMs can use to give human-readable responses or execute on tasks.

In this blog, we dive into this cool project I built using Langchain, Next.js, and Gaia's free compute for AI inferencing and free LLMs.

You can check out my demo video below also:

// Detect dark theme var iframe = document.getElementById('tweet-1920094583041474898-619'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1920094583041474898&theme=dark" }

How a PR review agent should work
Prerequisites and setup
Adding the agent actions
Adding the frontend
Putting it all together
Conclusion

How a PR review agent should work

Building a PR review agent, you would want to satisfy four few criteria in my opinion:

The agent has domain knowledge on a few languages and can understand them well enough with a low chance of hallucinating.
You have given the agent a well-written prompt of what you want it to do.
The agent has access to fetch and write data to your remote repository hosting option (GitHub, GitLab, or Bitbucket).
The agent should not expose confidential code to any external database.

You may have your opinion on a few other criteria that I am missing, but I am open to hearing them from you in the comments. We will also be using GitHub as our remote repository option here.

You can check out my finished project here in case you want to skip over the entire blog and just get straight to running the project:

https://github.com/tobySolutions/github-pr-review-agent

Prerequisites and setup

Access to Deepseek on Gaia
Gaia API key (make sure to enable Developer free trial)
Access to https://api.github.com/
GitHub API key for use with the requests
LangChain
Next.js for the frontend UI.

So, the approach I used here was to make simple actions in the LangChain setup as functions that we can then call in the frontend. These LangChain actions use Gaia for inferencing.

Setup

Step 1: Create a New Next.js Project

First, create a new Next.js project with TypeScript, Tailwind CSS, and the App Router:

npx create-next-app@latest github-pr-review

When prompted, select the following options:

Would you like to use TypeScript? Yes
Would you like to use ESLint? Yes
Would you like to use Tailwind CSS? Yes
Would you like to use src/ directory? No
Would you like to use App Router? Yes
Would you like to customize the default import alias? Yes (Use @/*)

Step 2: Install Dependencies

Navigate to your project directory and install the required dependencies:

cd github-pr-review

# Install UI and form dependencies
npm install @radix-ui/react-checkbox @radix-ui/react-alert @hookform/resolvers zod react-hook-form class-variance-authority clsx tailwind-merge lucide-react

# Install markdown and syntax highlighting
npm install react-markdown react-syntax-highlighter
npm install --save-dev @types/react-syntax-highlighter

# Install AI and API dependencies
npm install @langchain/openai

npm install @tailwindcss/typography

Step 3: Set Up shadcn/ui Components

We'll use shadcn/ui for our UI components. First, initialize it in your project:

npx shadcn@latest init

When prompted, select:

Would you like to use TypeScript? Yes
Which style would you like to use? Default
Which color would you like to use as base color? Slate
Where is your global CSS file? app/globals.css
Do you want to use CSS variables? Yes
Where is your tailwind.config.js located? tailwind.config.ts
Configure the import alias? @/

Now, install the required components:

npx shadcn@latest add button card form input checkbox alert

Step 4: Set Up Environment Variables

Create a .env.local file in the root of your project:

GITHUB_TOKEN=your_github_personal_access_token
GAIA_API_KEY=your_ai_api_key
GAIA_API_BASE_URL=your_ai_api_base_url
GAIA_MODEL=DeepSeek-R1-Distill-Llama-8B-Q5_K_M

Replace the placeholder values with your actual API keys and URLs.

Step 5: Create the Project Structure

Create the following file structure:

github-pr-review/
├── app/
│   ├── actions.ts
│   ├── globals.css (already exists)
│   ├── layout.tsx (already exists)
│   └── page.tsx (already exists)
├── components/
│   ├── review-form.tsx
│   ├── theme-provider.tsx
│   └── ui/ (created by shadcn/ui)
├── lib/
│   └── utils.ts (created by shadcn/ui)

Adding the agent actions

Create app/actions.ts with the following code:

"use server"

import { z } from "zod"
import { ChatOpenAI } from "@langchain/openai"

// Define Zod schema for the form input
const reviewInputSchema = z.object({
  owner: z.string().min(1),
  repo: z.string().min(1),
  prNumber: z.number().int().positive(),
  postComment: z.boolean().optional(),
})

// Define Zod schema for the state
const stateSchema = z.object({
  owner: z.string(),
  repo: z.string(),
  prNumber: z.number(),
  diff: z.string().optional(),
  feedback: z.string().optional(),
})

type ReviewState = z.infer<typeof stateSchema>

// Fetch GitHub PR diff
async function fetchPullRequestDiff(state: ReviewState): Promise<ReviewState> {
  const url = `https://api.github.com/repos/${state.owner}/${state.repo}/pulls/${state.prNumber}`

  try {
    const response = await fetch(url, {
      headers: {
        Accept: "application/vnd.github.v3.diff",
        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
      },
    })

    if (!response.ok) {
      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`)
    }

    const diff = await response.text()
    return { ...state, diff }
  } catch (error) {
    console.error("Error fetching PR diff:", error)
    throw new Error(error instanceof Error ? error.message : "Failed to fetch the pull request diff")
  }
}

// Analyze PR with AI
async function analyzeDiff(state: ReviewState): Promise<ReviewState> {
  if (!state.diff) throw new Error("No diff to analyze")

  try {
    const prompt = `You are an AI code reviewer. Review the following diff:\n\n\`\`\`diff\n${state.diff}\n\`\`\`\n\nGive categorized feedback on Style, Security, Performance, and Design. Format your response in Markdown with proper headings, lists, and code blocks where appropriate.`

    const llm = new ChatOpenAI({
      model: process.env.GAIA_MODEL || "gpt-4o",
      configuration: {
        apiKey: process.env.GAIA_API_KEY!,
        baseURL: process.env.GAIA_API_BASE_URL,
      },
    })

    const res = await llm.invoke(prompt)
    const content = typeof res === "string" ? res : (res as any)?.content || String(res)
    return { ...state, feedback: content }
  } catch (error) {
    console.error("Error analyzing diff:", error)
    throw new Error(error instanceof Error ? error.message : "Failed to analyze the pull request")
  }
}

// Post review back to GitHub
async function postGithubComment(state: ReviewState): Promise<void> {
  if (!state.feedback) return

  const url = `https://api.github.com/repos/${state.owner}/${state.repo}/issues/${state.prNumber}/comments`

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.GITHUB_TOKEN}`,
        Accept: "application/vnd.github.v3+json",
      },
      body: JSON.stringify({ body: state.feedback }),
    })

    if (!response.ok) {
      throw new Error(`Failed to post GitHub comment: ${response.statusText}`)
    }
  } catch (error) {
    console.error("Error posting GitHub comment:", error)
    throw new Error(error instanceof Error ? error.message : "Failed to post comment to GitHub")
  }
}

// Main server action
export async function reviewPullRequest(input: z.infer<typeof reviewInputSchema>) {
  try {
    // Validate input
    const validatedInput = reviewInputSchema.parse(input)

    // Initialize state
    const initialState: ReviewState = {
      owner: validatedInput.owner,
      repo: validatedInput.repo,
      prNumber: validatedInput.prNumber,
    }

    // Process the PR review
    const stateWithDiff = await fetchPullRequestDiff(initialState)
    const reviewedState = await analyzeDiff(stateWithDiff)

    // Post comment to GitHub if requested
    if (validatedInput.postComment) {
      await postGithubComment(reviewedState)
    }

    return {
      feedback: reviewedState.feedback,
      commentPosted: validatedInput.postComment || false,
    }
  } catch (error) {
    console.error("PR review error:", error)
    return {
      error: error instanceof Error ? error.message : "An unexpected error occurred",
    }
  }
}

Adding the frontend

Create components/theme-provider.tsx:

"use client"

import { ThemeProvider as NextThemesProvider } from "next-themes"
import type { ThemeProviderProps } from "next-themes"

export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
  return <NextThemesProvider {...props}>{children}</NextThemesProvider>
}

Step 8: Create the Review Form Component

Create components/review-form.tsx:

"use client"

import { useState } from "react"
import { useRouter } from "next/navigation"
import { zodResolver } from "@hookform/resolvers/zod"
import { useForm } from "react-hook-form"
import { z } from "zod"
import { Loader2, Github, Check } from 'lucide-react'
import ReactMarkdown from "react-markdown"
import { Prism as SyntaxHighlighter } from "react-syntax-highlighter"
import { vscDarkPlus } from "react-syntax-highlighter/dist/esm/styles/prism"
import type { CodeProps } from "react-markdown/lib/ast-to-react"

import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage } from "@/components/ui/form"
import { Input } from "@/components/ui/input"
import { Checkbox } from "@/components/ui/checkbox"
import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert"
import { reviewPullRequest } from "@/app/actions"

const formSchema = z.object({
  owner: z.string().min(1, "Repository owner is required"),
  repo: z.string().min(1, "Repository name is required"),
  prNumber: z.coerce.number().int("PR number must be an integer").positive("PR number must be positive"),
  postComment: z.boolean().default(false),
})

export function ReviewForm() {
  const router = useRouter()
  const [isLoading, setIsLoading] = useState(false)
  const [feedback, setFeedback] = useState<string | null>(null)
  const [error, setError] = useState<string | null>(null)
  const [commentPosted, setCommentPosted] = useState(false)

  const form = useForm<z.infer<typeof formSchema>>({
    resolver: zodResolver(formSchema),
    defaultValues: {
      owner: "",
      repo: "",
      prNumber: undefined,
      postComment: false,
    },
  })

  async function onSubmit(values: z.infer<typeof formSchema>) {
    setIsLoading(true)
    setFeedback(null)
    setError(null)
    setCommentPosted(false)

    try {
      const result = await reviewPullRequest(values)
      if (result.error) {
        setError(result.error)
      } else {
        setFeedback(result.feedback || null)
        setCommentPosted(!!result.commentPosted)
      }
    } catch (err) {
      setError("An unexpected error occurred. Please try again.")
      console.error(err)
    } finally {
      setIsLoading(false)
      router.refresh()
    }
  }

  return (
    <div className="space-y-8">
      <Form {...form}>
        <form onSubmit={form.handleSubmit(onSubmit)} className="space-y-6">
          <div className="grid gap-4 md:grid-cols-2">
            <FormField
              control={form.control}
              name="owner"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Repository Owner</FormLabel>
                  <FormControl>
                    <Input placeholder="e.g., vercel" {...field} />
                  </FormControl>
                  <FormDescription>The GitHub username or organization</FormDescription>
                  <FormMessage />
                </FormItem>
              )}
            />

            <FormField
              control={form.control}
              name="repo"
              render={({ field }) => (
                <FormItem>
                  <FormLabel>Repository Name</FormLabel>
                  <FormControl>
                    <Input placeholder="e.g., next.js" {...field} />
                  </FormControl>
                  <FormDescription>The name of the repository</FormDescription>
                  <FormMessage />
                </FormItem>
              )}
            />
          </div>

          <FormField
            control={form.control}
            name="prNumber"
            render={({ field }) => (
              <FormItem>
                <FormLabel>Pull Request Number</FormLabel>
                <FormControl>
                  <Input
                    type="number"
                    placeholder="e.g., 123"
                    {...field}
                    onChange={(e) => {
                      const value = e.target.value
                      field.onChange(value === "" ? undefined : Number(value))
                    }}
                  />
                </FormControl>
                <FormDescription>The number of the pull request to review</FormDescription>
                <FormMessage />
              </FormItem>
            )}
          />

          <FormField
            control={form.control}
            name="postComment"
            render={({ field }) => (
              <FormItem className="flex flex-row items-start space-x-3 space-y-0 rounded-md border p-4">
                <FormControl>
                  <Checkbox checked={field.value} onCheckedChange={field.onChange} />
                </FormControl>
                <div className="space-y-1 leading-none">
                  <FormLabel>Post review as a GitHub comment</FormLabel>
                  <FormDescription>The AI review will be posted as a comment on the pull request</FormDescription>
                </div>
              </FormItem>
            )}
          />

          <Button type="submit" className="w-full" disabled={isLoading}>
            {isLoading ? (
              <>
                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
                Analyzing PR...
              </>
            ) : (
              "Review Pull Request"
            )}
          </Button>
        </form>
      </Form>

      {error && (
        <Card className="border-red-300 bg-red-50 p-4 dark:border-red-800 dark:bg-red-900/20">
          <p className="text-red-800 dark:text-red-400">{error}</p>
        </Card>
      )}

      {commentPosted && (
        <Alert className="border-green-200 bg-green-50 dark:border-green-900 dark:bg-green-900/20">
          <Check className="h-4 w-4 text-green-600 dark:text-green-400" />
          <AlertTitle className="text-green-800 dark:text-green-400">Comment Posted</AlertTitle>
          <AlertDescription className="text-green-700 dark:text-green-500">
            The review has been successfully posted as a comment on the GitHub pull request.
          </AlertDescription>
        </Alert>
      )}

      {feedback && (
        <div className="rounded-lg border bg-white p-6 shadow-sm dark:border-gray-800 dark:bg-gray-900">
          <div className="mb-4 flex items-center justify-between">
            <h2 className="text-xl font-semibold text-gray-800 dark:text-white">AI Review Feedback</h2>
            <div className="flex items-center text-sm text-gray-500 dark:text-gray-400">
              <Github className="mr-1 h-4 w-4" />
              <span>
                {form.getValues().owner}/{form.getValues().repo}#{form.getValues().prNumber}
              </span>
            </div>
          </div>
          <div className="prose max-w-none dark:prose-invert">
            <ReactMarkdown
              components={{
                code(props) {
                  const { children, className, node, ...rest } = props as CodeProps
                  const match = /language-(\w+)/.exec(className || "")
                  return !props.inline && match ? (
                    <SyntaxHighlighter {...rest} style={vscDarkPlus} language={match[1]} PreTag="div">
                      {String(children).replace(/\n$/, "")}
                    </SyntaxHighlighter>
                  ) : (
                    <code {...rest} className={className}>
                      {children}
                    </code>
                  )
                },
              }}
            >
              {feedback}
            </ReactMarkdown>
          </div>
        </div>
      )}
    </div>
  )
}

Then you update app/page.tsx:

import { ReviewForm } from "@/components/review-form"
import { GithubIcon } from 'lucide-react'

export default function Home() {
  return (
    <main className="min-h-screen bg-gradient-to-b from-gray-50 to-gray-100 dark:from-gray-900 dark:to-gray-800">
      <div className="container mx-auto px-4 py-16">
        <div className="mx-auto max-w-3xl">
          <div className="mb-8 flex items-center justify-center gap-3">
            <GithubIcon className="h-8 w-8 text-gray-800 dark:text-white" />
            <h1 className="text-center text-3xl font-bold text-gray-800 dark:text-white">GitHub PR Review AI</h1>
          </div>

          <div className="rounded-lg border bg-white p-6 shadow-sm dark:border-gray-800 dark:bg-gray-900">
            <p className="mb-6 text-center text-gray-600 dark:text-gray-400">
              Enter your GitHub repository details to get an AI-powered code review for your pull request.
            </p>
            <ReviewForm />
          </div>
        </div>
      </div>
    </main>
  )
}

Update the Root Layout

Update app/layout.tsx to include the theme provider:

import type { Metadata } from "next"
import { Inter } from 'next/font/google'
import "./globals.css"
import { ThemeProvider } from "@/components/theme-provider"

const inter = Inter({ subsets: ["latin"] })

export const metadata: Metadata = {
  title: "GitHub PR Review AI",
  description: "AI-powered code reviews for your GitHub pull requests",
}

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en" suppressHydrationWarning>
      <body className={inter.className}>
        <ThemeProvider attribute="class" defaultTheme="system" enableSystem disableTransitionOnChange>
          {children}
        </ThemeProvider>
      </body>
    </html>
  )
}

Then update your tailwind.config.ts:

import type { Config } from "tailwindcss"

const config = {
  darkMode: ["class"],
  content: [
    "./pages/**/*.{ts,tsx}",
    "./components/**/*.{ts,tsx}",
    "./app/**/*.{ts,tsx}",
    "./src/**/*.{ts,tsx}",
  ],
  theme: {
    container: {
      center: true,
      padding: "2rem",
      screens: {
        "2xl": "1400px",
      },
    },
    extend: {
      colors: {
        border: "hsl(var(--border))",
        input: "hsl(var(--input))",
        ring: "hsl(var(--ring))",
        background: "hsl(var(--background))",
        foreground: "hsl(var(--foreground))",
        primary: {
          DEFAULT: "hsl(var(--primary))",
          foreground: "hsl(var(--primary-foreground))",
        },
        secondary: {
          DEFAULT: "hsl(var(--secondary))",
          foreground: "hsl(var(--secondary-foreground))",
        },
        destructive: {
          DEFAULT: "hsl(var(--destructive))",
          foreground: "hsl(var(--destructive-foreground))",
        },
        muted: {
          DEFAULT: "hsl(var(--muted))",
          foreground: "hsl(var(--muted-foreground))",
        },
        accent: {
          DEFAULT: "hsl(var(--accent))",
          foreground: "hsl(var(--accent-foreground))",
        },
        popover: {
          DEFAULT: "hsl(var(--popover))",
          foreground: "hsl(var(--popover-foreground))",
        },
        card: {
          DEFAULT: "hsl(var(--card))",
          foreground: "hsl(var(--card-foreground))",
        },
      },
      borderRadius: {
        lg: "var(--radius)",
        md: "calc(var(--radius) - 2px)",
        sm: "calc(var(--radius) - 4px)",
      },
    },
  },
  plugins: [require("tailwindcss-animate"), require("@tailwindcss/typography")],
} satisfies Config

export default config

Finally, run the development server

npm run dev

Visit http://localhost:3000 in your browser to see the application running.

Putting it all together

The above is an agent that automatically analyzes pull request diffs using AI models to provide instant code feedback. It fetches PR changes from GitHub, generates comprehensive reviews categorized by style, security, performance, and design considerations.

The app can optionally post these AI-generated reviews directly as comments on GitHub PRs, helping developers identify issues before human reviewers even look at the code.

Cet finit!

Conclusion

This project is a glimpse into how AI agents are transforming developer workflows—from static tools to intelligent collaborators. By integrating LangChain, Gaia's free LLMs, and GitHub’s API within a Next.js frontend, we created a practical, automated PR review agent that’s both easy to deploy and powerful enough to offer real value.

As AI tooling matures, expect these kinds of agentic workflows to become the norm—handling repetitive review tasks, improving code quality, and freeing up time for more creative engineering work.

Give it a try, tweak it to your needs.

You really need to check this out if you’re in Web3

Tobiloba Adedeji — Wed, 09 Apr 2025 06:54:29 +0000

Opeyemi Stephen

Apr 8 '25

Why Web3 Keeps Losing Users (And How We Actually Fix It in 2025)

#web3 #blockchain #ux #onboarding

Comments 4

12 min read

How to create a decentralized AI agent with Gaianet.

Tobiloba Adedeji — Wed, 02 Apr 2025 10:19:24 +0000

In the evolving AI ecosystem, computing power and decentralization are becoming equally and increasingly important. Decentralized AI has proposed a lot of solutions to many problems that centralized AI providers had, and a lot of these solutions have been tested and verified. Nowadays, many projects have claimed the ability to build “decentralized” AI agents, but a closer look reveals otherwise.

Projects claim to build decentralized AI agents or applications using largely centralized infrastructure. Some of these agents can make a few onchain calls and interactions and that apparently makes them claim decentralized? NO!

Before going further, what does it mean to have truly decentralized AI agents? Off the top of my head, a few key features should be:

Infrastructure decentralization: AI computation happens across distributed nodes rather than in centralized data centers owned by a few corporations. The processing power comes from many individual nodes running on hardware in different locations.
Model ownership: Instead of a few large organizations controlling the AI models, decentralized AI allows individuals and smaller entities to own, operate, and customize their models, distributing the power of AI more broadly.
Data sovereignty: In a truly decentralized AI system, data used for training and inference can remain under the control of its creators or rightful owners, rather than being held by centralized organizations. This addresses privacy concerns and data exploitation issues.

And many more features such as: Resilience, Reduced Censorship Risk, and Knowledge Diversity.

What is Gaianet?

Gaianet is a decentralized computing infrastructure designed to democratize AI agent creation. Unlike traditional AI services that are tied to specific companies, Gaianet allows you to create AI agents that reflect your unique style, values, knowledge, and expertise. Each Gaianet node provides:

A web-based chatbot UI for direct interaction
An OpenAI-compatible API that works seamlessly with existing AI applications
Customization options including fine-tuned models and specialized knowledge bases

Gaianet offers a powerful solution that enables individuals and businesses to create, deploy, scale, and monetize their own AI agents without relying on centralized platforms.

In this guide, I'll walk you through the process of creating your own decentralized AI agent using Gaianet.

Prerequisites

Before getting started, ensure your system meets these minimum requirements:

System	Minimum Requirements
OSX with Apple Silicon (M1-M4 chip)	16GB RAM (32GB recommended)
Ubuntu Linux 20.04 with Nvidia CUDA 12 SDK	8GB VRAM on GPU
Azure/AWS	Nvidia T4 GPU Instance

Note: If you're using a Windows system, you should have Ubuntu installed so you can use WSL in the command line.

Step 1: Installing your Gaianet node

1.Download the latest version of the Gaianet node:

curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash

2.Set up the environment path using the command printed in your terminal (starts with source).
3.Initialize your Gaianet node:

gaianet init

This command initializes your node according to the configuration in $HOME/gaianet/config.json.

By default, it comes with Llama 3.2 LLM and a knowledge base about Paris. Be patient, as this step involves downloading a large LLM file.

4.Start your node:

gaianet start

Step 2: Accessing your AI agent

After a successful startup, your terminal will display a public URL for your node, similar to:

https://{YOUR_NODE_ID}.gaianet.xyz

Opening this URL in your browser will display node information and allow you to chat directly with your AI agent.

To stop your node at any time, simply run:

gaianet stop

Customizing your AI agent

The default setup comes with a Phi-3 model and Paris knowledge base, but the real power of Gaianet lies in customization and tool integrations. Here's how to make your AI agent truly your own.

The steps for creating a knowledge base and further agent customization can be found in the guide here. Some of the possible options for your Gaia setup are:

Choose or fine-tune a model: Select a model that aligns with your specific use case, or fine-tune an existing model to "speak" like you.
Create a knowledge base: Populate your AI agent with specialized knowledge in your domain of expertise.
Configure node settings: Adjust performance parameters, conversation styles, and other settings to match your requirements.
Implement tool connections: Connect your agent to external tools and data sources to extend its capabilities.

Integration with the broader ecosystem

Your Gaianet node is compatible with various agent applications in the OpenAI ecosystem. You can use any Gaia node as the backend LLM provider with:

DifyAI
Open WebUI
Anything LLM
Cursor AI IDE
Obsidian
CodeGPT

Many more integrations can be found on the Gaianet documentation.

Benefits of creating a decentralized AI agent

Ownership and control: You maintain complete control over your AI agent's functionality and data.
Customization: Create an agent that genuinely reflects your expertise and values.
Privacy: Keep sensitive data localized rather than sharing it with centralized services.
Monetization: Generate income from your specialized knowledge and unique AI agent capabilities.
Interoperability: Your agent works with the broader ecosystem of AI tools and applications.

Monetizing your AI agent

One of Gaianet's unique features is the ability to join the Gaianet Protocol network and receive payments for your AI agent's services:

Join the Gaianet Protocol using the documentation provided in the "Joining the Gaianet Protocol" section.
Ensure node reliability for stable service delivery.
Set pricing for API access to your specialized AI agent.

Conclusion

Creating a decentralized AI agent with Gaianet opens up new possibilities for personalized AI experiences. Whether you're a developer looking to build specialized tools, a business seeking to enhance customer service, or a knowledge worker wanting to scale your expertise, Gaianet provides the infrastructure to make it happen.

Ready to get started? Go to the Gaianet documentation for more detailed information and join the Gaianet community on Discord and Twitter to connect with other builders and users.

How to deploy a Twitter Grok AI agent on Fleek

Tobiloba Adedeji — Wed, 26 Feb 2025 08:04:28 +0000

Grok, built by xAI, is a cutting-edge conversational AI designed to give helpful, truthful answers with a dash of humor and an outside perspective on humanity. It’s powered by a large language model (LLM)—think massive neural networks trained on vast amounts of text to understand and generate human-like responses.

The latest iterations, like Grok-3, pack advanced reasoning, real-time data access (via platforms like X), and multimodal capabilities (handling text, images, and more).

In this guide, we will go over deploying a Grok Eliza AI agent on Fleek.

Prerequisites

An XAI API key and credits in your account.
A Fleek account if you don’t already have one.
A Twitter account with existing authentication and login status

No prior knowledge of AI agents or Eliza is required to participate.

How to get your Grok API key

To get a Grok API key:

Navigate to the XAI console and then sign in to the console.
In the sidebar, tap the key icon labeled "API Keys." You'll find the following panel:

3.Next, click on "Create API key". Note that you must have API credits in your account for the API key to be valid.

Deploy your AI agent from Fleek

Start by going to fleek.xyz/eliza/. You'll find three deployment options. Go ahead and select the “Start with a template” option:

Next, select a template that fits your preferences, e.g., C-3PO template.

Click on the C-3PO button, the form on the page will be filled instantly with the necessary details.
Locate "Model providers" and click to reveal the dropdown options.
Scroll to find "Grok" in the dropdown menu as shown below::

4.After selecting Grok, no additional configuration is necessary. However, you have the option to customize your experience by adding an avatar or updating the name as desired.

5.Once ready, scroll to the bottom and click the "Continue to settings" button.

6.Fill in all the necessary information on this panel. You'll notice that some fields are already completed, which you can skip.

7.Once completed, examine your agent details carefully to ensure all provided information is correct.

Note: Advanced users can switch to the "JSON" (Characterfile) tab to manually edit or modify configuration details.

8.After review, click "Deploy agent" at the bottom. Your agent should be active in a few seconds.

Great! Your agent will be live on X and ready to interact. Tag it for responses or head back to edit its Characterfile anytime:

To learn more, check out:

I put a Deepseek AI agent on Fleek

Tobiloba Adedeji — Mon, 03 Feb 2025 13:56:47 +0000

You may have seen the recent Deepseek release trending online about and of course, I am here today again to show you how you can put your own AI agent using Deepseek on Fleek in less than 3 minutes.

Prerequisites

Before we dive in, ensure you have done the following:

Go to fleek.xyz/eliza
Create a Fleek account if you have not already.
Go to your Telegram and look for BotFather. Connect with it, create a new bot and then copy that bot token.
Deepseek API key

After all the above go to the fleek.xyz/eliza page and select the "Choose a template" option. We will use the "dobby" template this time to create our agent.

Creating and deploying the agent

Fleek already has Dobby as a template, so you can just select it from the options below:

After the above, you can now go ahead and deploy now:

1.In the "Model Provider" input, select Deepseek

2.Review all details to see if you are okay with all of them
3.Scroll to the bottom and click on "Continue to settings"
4.Add your "DEEPSEEK_API_KEY" to the appropriate field

5.Click on "Deploy agent"

In just five steps you can put your Deepseek agent live on Fleek.

Thank you!!

Create and deploy an AI agent that can generate images on Fleek in 6 steps.

Tobiloba Adedeji — Tue, 28 Jan 2025 15:21:54 +0000

My articles may have been a lot about deploying AI agents a lot, but, honestly that is something that a lot of my work and experimentation has been about lately!

So, today I will be deploying a C-3PO with Image generation capabilities on Fleek and I'll be using Telegram! So, let's dive in!

Prerequisites

Before we dive in, ensure you have done the following:

Go to fleek.xyz/eliza
Create a Fleek account if you have not already.
OpenAI API key
Go to your Telegram and look for BotFather. Connect with it, create a new bot and then copy that bot token.

You do not need any technical experience whatsoever to deploy an AI agent on Fleek.

Creating and deploying the agent on Fleek

1.Go to fleek.xyz/eliza
2.Fleek already has C-3PO as a template. Go to "Start with a template"

3.Click on the button that says C-3PO, scroll to the bottom and go to the next page.

4.Ensure you have Telegram set as the client and that you have the image generation plugin set:

5.You only need values for these two in your secrets:

6.Fill those in and click on "Deploy agent". Your agent should go live in less than 20 seconds. Go back to Telegram to test our agent and you'll see it working:

Deploying a C-3PO agent with image generation capabilities on Fleek using Telegram is a seamless and beginner-friendly process. With Fleek’s pre-built templates and straightforward setup, you can bring your AI-powered bot to life in minutes without any technical expertise.

By simply connecting your Telegram bot, configuring a few secrets, and selecting the image generation plugin, your personalized AI agent is ready to deliver engaging and creative responses. Whether you're testing its capabilities or sharing the results with friends, the deployment process ensures an effortless and exciting experience. Go ahead, get creative, and enjoy exploring the possibilities with your AI agent!

Forem: Tobiloba Adedeji

I Built a Personal Operating System on Claude Code and Open-Sourced It

What makes it an OS and not a prompt collection

The commands I run every day

/daily-sync

/apply jobs and the resume tailor

/write

/outreach and /interview-prep

Why files instead of a database

How commands compose into a pipeline

Fork it and make your own

The gap nobody's filling

Agent Architectures: A Map

The Map

Copilot

Daemon

Subagent

Workflow

Hybrids

A note on frameworks

Close

MCP-Powered Agents: Wiring Gaia to ACI Tools

What you’ll build

Architecture

Prerequisites

One-time ACI platform setup

Environment

Install dependencies

Minimal working example

Why this pattern works

Extending beyond “star repo”

Troubleshooting

MCP note

Wrap-up

Building an AI-Powered Minecraft Agent with Gaia

The In-Game Assistant Challenge

Solution: Gaia + LangChain + Mineflayer

Architecture: From Chat to Action

Bot Setup

LLM Integration with Gaia

Dynamic Tools: Giving the Bot Superpowers

Handling Player Chat Commands

AI in Action

User Experience Design

Real-World Use Cases

Deployment & Configuration

Why Gaia’s Decentralized Approach Matters

Future Enhancements

Conclusion: More Than a Minecraft Mod

YES! Decentralized AI agents with MCP support are a thing.

Run a decentralized MCP application with Gaia

Run a decentralized MCP application with Gaia

What Are Gaia and MCP? (And Why Decentralization Matters)

Setting Up Gaia with MCP Support

Configuring the Weather MCP Server (mcp_config.toml)

Launching Gaia and Getting Weather Responses

Wrapping Up: The Potential of Gaia + MCP

Build a personal PR-reviewer with Gaia, Langchain, and Next.js.

Contents

How a PR review agent should work

Prerequisites and setup

Setup

Step 1: Create a New Next.js Project

Step 2: Install Dependencies

Step 3: Set Up shadcn/ui Components

Step 4: Set Up Environment Variables

Step 5: Create the Project Structure

Adding the agent actions

Adding the frontend

Step 8: Create the Review Form Component

Putting it all together

Conclusion

You really need to check this out if you’re in Web3

Why Web3 Keeps Losing Users (And How We Actually Fix It in 2025)

How to create a decentralized AI agent with Gaianet.

What is Gaianet?

Prerequisites

Step 1: Installing your Gaianet node

Step 2: Accessing your AI agent

Customizing your AI agent

`/daily-sync`

`/apply jobs` and the resume tailor

`/write`

`/outreach` and `/interview-prep`