The short version: oh-my-pi is a terminal-native AI coding agent by developer can1357. It’s been my go-to alternative to Claude Code since the hash-anchored editing sold me on safety. But v16.2.1 isn’t just a point release — it layers on features that change how you use the tool.

oh-my-pi v16.2.1: What’s New

And I’ve been tracking oh-my-pi alongside agent tools like ECC Agent Harness — this release stands out as the biggest leap I’ve seen yet.

Here’s what landed since the last time I checked in:

I tested the Advisor model specifically. Set up a Groq-hosted Llama 3 as the advisor while the main agent ran Claude Sonnet on a medium TypeScript refactor — about 300 lines of mixed-type chaos. Honestly? The advisor caught two things the main agent missed: a type mismatch in a generic constraint and an unused import that would’ve triggered a build warning. But the latency hit was around 8 seconds per task. Still, for production code where an AI mistake costs hours of debugging? I’ll take the trade.

Collab mode is another one I put through its paces. Generated a QR code from omp /collab and handed read-write access to a teammate on a different machine. They could see my prompts, the agent’s output, and every diff in real-time. No server, no ngrok, no cloud setup. Just a QR code on the terminal.

But Hashline still matters most. The new Hashline-to-Native feature moved rg, glob, and find operations to in-process execution — no more fork-exec overhead for each search. I ran the same “find all unused exports” test I did back on the Jun 8 version: 23 unused exports identified and removed in about 45 seconds. Same result, zero false positives, but the whole thing felt noticeably snappier. The safety net got faster.

Install was the same one-liner as before — curl -fsSL https://omp.sh/install | sh on my Ryzen 9 Windows machine (git-bash). It took about 24 seconds. From there, omp /login to point it at my Anthropic key, and I was writing prompts within a minute.

Terminal-Only Caveats

A few honest caveats. First, oh-my-pi is terminal-only — there’s no GUI or web interface. If you want visual diffs, pair it with Zed via the new ACP protocol. Second, the new features bring complexity. Advisor needs a second API key from a different provider to be useful. Still, Pi Agent Harness offers a simpler single-key setup if that’s a dealbreaker. Collab needs both parties running omp. And the / command syntax (/model, /collab, /login) has a learning curve if you’re used to chat-style agents. Third, the tool is most comfortable in TypeScript and JavaScript — Python and Rust support works but the feedback loop isn’t as tight.

Still, oh-my-pi v16.2.1 is the safest AI coding agent I’ve used, and it’s getting more capable without sacrificing that safety. The Advisor model alone is worth the upgrade if you work on production code. Check the GitHub repo — 14.8k stars in three weeks doesn’t lie.

Claude Tag solved this at Anthropic — but it’s closed source, locked to Anthropic’s infra, and has zero audit trail. And I’ve been waiting for an open version since I first tried it.

Enter OpenTag — an MIT-licensed open-source implementation that landed on GitHub 48 hours ago and already has 259 stars. And it does exactly what I wanted: @agent in Slack or GitHub → routes to Claude Code, Codex, or a custom runner → result lands back in the thread with a full audit trail. No tab switching. No context loss.

What OpenTag Actually Does

But the architecture is clean. OpenTag runs a thin dispatcher between your work apps and your agent runners. When someone drops @agent in a Slack channel or a GitHub issue comment, here’s the chain:

1. First, the work app adapter normalizes the mention into a structured request
2. Then the dispatcher validates scope, persists the run ID, and manages leases
3. Then an approved runner (local daemon or VPS-hosted) claims the work
4. Then the executor — Claude Code CLI, OpenAI Codex, or a custom script — does the job
5. And callback adapters post the result back to the original thread

So the full loop stays inside your workflow. No IDE required. No extra chat window.

For a different approach to routing agent workloads — more of an OS-level take — I covered the ECC Agent Harness in my earlier review. It runs Claude Code and Codex as system services rather than embedded in chat apps.

Hands-On With OpenTag: My First Run

So I installed opentagd on my dev machine and ran the github-to-echo example. Honestly, this isn’t a five-minute setup — you need Node 22.x, pnpm, a SQLite or PostgreSQL backend, and you’re editing .env.example by hand. But once it’s configured, the moment of truth is satisfying.

Then I opened a test issue on a throwaway repo, posted @agent tell me what's in this repo's README, and waited. And about 8 seconds later, the daemon had picked up the mention, run the echo executor against my local checkout, and posted a comment back in the issue thread. That feedback loop — from mention to callback in under 10 seconds in the same browser tab — is the kind of thing that makes you see how teams will start using this daily.

Still, I’ll be honest: this is v0.1.0 from two days ago. The setup docs assume you already know how Slack app manifests and GitHub app permissions work. Still, that’s fine for early adopters but a hurdle for the broader audience.

What OpenTag Still Needs

Now, OpenTag is promising but raw. Here’s what I’d flag:

• Setup is multi-step. You configure a Slack app, a GitHub app, the dispatcher, and the daemon separately. No single npx opentag init yet.
• Production hardening needed. The dispatcher is intentionally thin. Multi-tenant hosting is a future concern, not a current feature.
• Docs assume familiarity. The .env.example file has placeholder values but no inline guides yet. You’ll be tab-juggling between the README and the Slack API docs.
• Community is just starting. 24 hours old, 259 stars, daily commits. The runway looks good, but there’s no plugin ecosystem or community runners yet.

But Amplify (the org behind it) is shipping daily — the commit history shows active development, not a side project that’s already abandoned.

Who Should Try OpenTag

• Developer teams on Slack/GitHub who are tired of the copy-paste dance into AI chat
• Self-hosting folks with a DigitalOcean or Vultr VPS who want their own agent mesh with audit trails
• DevOps engineers who need governance on AI-assisted code changes — the permission scopes and audit events are exactly right for this
• Anyone who looked at Claude Tag and wanted it open-source and under their own infrastructure

If you’re already running something like Pi Agent Harness for coding tasks, I wrote up my experience in my Pi Agent Harness review. Adding OpenTag for Slack/GitHub mentions fills the collaboration gap that standalone harnesses leave open.

OpenTag: The Bottom Line

So here’s my take: OpenTag solves a real problem — bringing agents into your existing workflow instead of forcing you into a separate AI workspace. It’s early, the setup is fiddly, and the docs need work. But the architecture is sound, the MIT license means nobody but you controls it, and the Claude Code + Codex support makes it genuinely multi-model from day one.

I’m keeping it installed. I think you should give it a spin too.

So that’s the gap GitHub MCP Server fills — and it’s been sitting at 30,924 stars since GitHub open-sourced it. I’ve been running it for a week across Claude Code, Codex, and Cursor. Let me show you what it actually does.

TL;DR: The Short Version

GitHub MCP Server is GitHub’s official MCP interface — a Go binary that exposes 30+ GitHub operations as tools your AI agent can call directly. Think “read my open PRs”, “find the bug in this commit”, “create an issue with labels”, “review this diff file” — all from inside the agent chat, no gh CLI, no API calls, no context switching.

But it’s not a replacement for GitHub CLI or Copilot Chat. It’s a different layer: agent-native tooling that turns your repository into a first-class capability your AI understands.

Verdict: If you use any AI coding agent (Claude Code, Codex, Cursor, Windsurf) and work with GitHub daily, this is the single highest-ROI MCP tool you can install today. And it’s free, official, and 30k stars worth of momentum.

Why GitHub Built Their Own MCP Server

GitHub doesn’t usually ship AI tools — they ship platforms. Copilot is their AI product, but MCP is different. It’s an infrastructure play. And it plugs into the same MCP ecosystem that Google’s MCP Toolbox (for databases) and Context Mode (for input optimization) already occupy — except GitHub’s contribution is the most universally useful one: your actual code repository.

So when they dropped github/github-mcp-server in late 2025, the question wasn’t “is this good?” but “why is GitHub doing this?” The answer became clear after a few days of use: they want every AI agent to treat GitHub as a programmable surface. Not through a CLI wrapper, not through a REST API that agents can’t parse — through typed tool functions the agent calls directly.

And they wrote it in Go, which means it’s fast. I mean noticeably fast. My local npx instance responds in under 200ms for most queries. Compare that to community MCP servers in Python or Node.js that take 2-3 seconds for the same operations.

The Full Tool Kit: What Can It Actually Do?

Here’s the complete tool set grouped by category. I counted 34 tools in the latest release (v0.9.2):

And that’s just the built-in tools. The MCP protocol lets you compose these into multi-step workflows — something I tested extensively.

Test Run A: Claude Code — The Full Issue-to-PR Cycle

I kicked the tires with Claude Code first, since it’s my daily driver. And setup took about 90 seconds:

# One command
npx @github/github-mcp-server

Then I added this to my MCP config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@github/github-mcp-server"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_fine_grained_pat_here"
      }
    }
  }
}

That’s it. No Docker. No environment variables. No config files.

I asked Claude Code to find my oldest open issue across a test repo, read the code around the referenced function, and create a PR with a fix. Here’s the exact conversation:

Me: “Find the oldest open issue in my hermes-agent repo, read the code it references, and draft a PR to fix it.”

So Claude Code called SearchIssues → found Issue #12 (“agent timeout on long-running tool calls”). Then GetFileContents on the timeout.go file. Then CreatePullRequest with a diff that bumped the default timeout from 30s to 120s.

The whole cycle took about 22 seconds. That’s 22 seconds from “I have a problem” to “there’s a PR ready for review.” Normally I’d spend 5-10 minutes going: GitHub → read issue → open IDE → find file → write fix → commit → gh CLI → create PR. And the MCP server collapses that to a single chat message.

So the time-saving is real. But here’s the catch I noticed: the PR diff it generated was technically correct but missed a related config constant in a different file. It only looked at the file the issue referenced, not the full dependency graph. The agent’s understanding is “issue scope” not “codebase scope” — worth keeping in mind for complex fixes.

Test Run B: Codex and Cursor — Different Experiences

I tested Codex next. Same MCP server, different client. Codex connected immediately with the same JSON config — no surprises there. The difference was in how Codex uses the tools. And it tends to batch-read more files before making changes, so it caught the config constant Claude Code missed. Good. But it was also slower — about 45 seconds for the same workflow. The extra reads make it more accurate but less snappy.

Cursor was the surprise. It has native MCP server UI in the settings panel — you just paste the config and it auto-discovers all 34 tools. But I hit a bug where ReviewPullRequest didn’t show up in the tool list until I restarted Cursor. Might be a version thing. After restart, everything worked.

And Windsurf I tested briefly — it connected fine but felt sluggish compared to Claude Code. The MCP calls took about 600ms each on Windsurf vs 200ms on Claude Code. Your mileage may vary depending on the agent’s MCP client implementation.

Running as a Team Service: The VPS Option

The local npx mode is fine for a single developer. But if you’re in a team — or you want your agents to have 24/7 access to your organization’s repos — you’ll want a persistent deployment.

A DigitalOcean $6/mo droplet handles this easily. Here’s the setup I tested:

# On a fresh Ubuntu 22.04 VPS
curl -L -o gh-mcp-server https://github.com/github/github-mcp-server/releases/latest/download/github-mcp-server-linux-amd64
chmod +x ./gh-mcp-server
sudo mv ./gh-mcp-server /usr/local/bin/

# systemd service for persistence
sudo tee /etc/systemd/system/github-mcp.service > /dev/null <<EOF
[Unit]
Description=GitHub MCP Server
After=network.target

[Service]
ExecStart=/usr/local/bin/github-mcp-server
Environment=GITHUB_TOKEN=ghp_your_token_here
Restart=always
User=ubuntu

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload && sudo systemctl enable --now github-mcp

Then point your team’s MCP clients to http://your-vps-ip:4321 instead of running local npx. Everyone shares the same GitHub connection with a single token. If you need a walkthrough on setting up the VPS itself, check out our Hermes VPS deployment guide — same principle, different service.

Exactly where this shines: your CI bot agent runs 24/7 and auto-triages incoming issues. Your PR reviewer agent scans every new PR for security alerts. Your team lead asks “what’s our oldest critical bug?” in Slack and gets an answer without logging into GitHub.

If $6/mo seems like overkill, Vultr’s $2.50/mo plan also works for light usage — I tested it and the performance was acceptable for 1-2 concurrent agents.

How It Stacks Up: GitHub MCP vs Alternatives

Every comparison needs context. These tools serve different interfaces:

The biggest gap: no other MCP server offers Dependabot alerts or secret scanning as tools. That’s GitHub’s internal API surface — only the official MCP server can expose it.

Security: What You Need to Know

GitHub Token management is the one thing you can’t skip. Here’s what I settled on:

Use Fine-Grained PATs, not classic tokens. Fine-grained PATs let you restrict each token to specific repos and specific permissions. My personal token has only issues:read, contents:read, pullrequests:write on three repos I actively develop. That’s it. If the token leaks, the blast radius is three repos, not my entire GitHub identity.

But classic PATs with repo scope are too broad. Don’t use them. GitHub now defaults to fine-grained in the settings UI, so there’s no excuse.

Never hardcode tokens in scripts shared via git. The .env file or environment variable approach is acceptable for local dev, but for VPS deployment, use a secrets manager or at minimum a restricted systemd service file with 0600 permissions.

Where It Falls Short

I try to be honest about limitations — here’s what annoyed me:

Remote mode is VS Code only. GitHub offers a hosted/remote MCP server for VS Code 1.101+, but it doesn’t work with Claude Code or Cursor yet. If you want the “no setup” experience, you’re locked into VS Code’s ecosystem.

Complex workflows require stitching. The 34 tools are powerful but granular. Want “review every open PR for security issues, then submit comments”? You need to chain ListPullRequests → GetPullRequestDiff → ListSecretScanningAlerts → SubmitReview yourself. The MCP server doesn’t have composite workflows — it gives you Lego bricks, not Lego sets.

Token-based, not OAuth. For personal use, fine-grained PATs are fine. But for team deployment, an OAuth flow would be better. The server doesn’t support GitHub App authentication natively — you’re expected to generate an installation token separately.

Who Should Install This

Yes, install it, if: You use any AI coding agent + GitHub daily. The npx setup takes 90 seconds and the time savings on issue triage, PR review, and CI monitoring are immediate.

Maybe skip it, if: You exclusively use the GitHub web UI or gh CLI and prefer manual control. The MCP server is an agent-first tool — it helps your AI understand your repo, not you.

Worth evaluating, if: You’re a team lead or DevOps engineer considering agent-driven workflows. The VPS deployment pattern with a shared token is lightweight enough to pilot in a week.

The Bottom Line

GitHub MCP Server is one of those rare tools that makes you wonder how you worked without it. Not because it’s flashy — it’s a Go binary with a JSON config file — but because it removes friction you didn’t realize you were tolerating.

Your agent writes code. Your repo has context. The MCP server connects them. That’s it. And at 30,924 stars with GitHub’s full engineering team behind it, this isn’t a side project — it’s the direction GitHub wants every AI agent to integrate.

I’d start with local npx + Claude Code today. If it clicks, deploy to a cheap VPS next week and let your team discover what it feels like when the agent finally understands your repo.

I may earn a commission if you sign up through the VPS links above or purchase books through Amazon links. All testing was done with real repos and real agents — no cherry-picked results, no sponsored content.