I hit this wall last week. I had a long-running session on my workstation. Then I had to leave. And I couldn’t check in from my phone, couldn’t SSH in to see if it finished, couldn’t do anything except wait. So when I found lfg—a web UI control plane for AI coding agents—I spun up a $6 DigitalOcean Droplet and installed it immediately. Here’s what happened.

Quick Verdict

lfg turns any Linux or macOS machine into a private control room for Claude Code, Codex, and OpenCode. One curl | bash install gives you a PWA web UI to launch, monitor, and interact with agent sessions from anywhere. It’s not an agent itself. It’s the infrastructure around the agents you already use. And it solves a real problem that raw tmux and SSH just don’t address well.

The short version: If you run AI coding agents on a remote server, lfg is worth installing right now. It’s 95 stars on GitHub, MIT licensed, and the setup took me under two minutes.

What Is lfg?

lfg (GitHub: BennyKok/lfg) is a lightweight control plane for AI coding agents. Think of it as a web-based mission control for Claude Code, Codex CLI, and OpenCode. You install it on your server, authenticate your agent CLIs, and access everything through a browser or PWA.

Here’s the key distinction: lfg doesn’t replace your agent. It gives you a UI to manage multiple sessions, watch live transcripts, answer prompts remotely, and keep everything running even after you close your laptop. Under the hood it uses tmux for session persistence, so your agents keep working whether the UI is open or not.

I’ve been running it for a few days now. And honestly? It fills a gap I didn’t realize was there until I had it.

If you’ve used tools like Godcoder or oh-my-pi—both of which run agents on your local machine—lfg solves the opposite problem: running them remotely and checking in from anywhere.

Quick Start: Run Claude Code With lfg on a VPS in 5 Minutes

I tested this on a fresh Ubuntu 24.04 Droplet. Here’s exactly what I did:

1. Spin up a VPS — I used a $6/mo DigitalOcean Droplet (2 GB RAM, 1 vCPU, 50 GB SSD). Any Ubuntu or Debian server will work.
2. SSH in and run the installer:

   curl -fsSL https://raw.githubusercontent.com/BennyKok/lfg/main/scripts/setup.sh | bash
   

3. Authenticate your agents — The script installs Node.js and bun, then prompts you to authenticate each CLI.
4. Open the web UI — Visit http://<your-vps-ip>:8766 in your browser.

And that’s it. From SSH login to seeing the web UI took me about 90 seconds of active work. The installer handles dependencies, sets up tmux, and configures auto-restart.

But here’s the part I really like: you don’t need Docker. Unlike most self-hosted tools that require a Docker Compose stack, lfg is a single binary managed by bun. That makes it feel much lighter on a $6 VPS.

lfg Web UI: Managing Agent Sessions From Anywhere

Now the web UI is where lfg shines. It’s a clean, responsive PWA that works in any browser. Here’s what I found after using it for a few days:

Session management — A dashboard shows all running agent sessions. Each one displays status, agent type, and a live transcript stream. You can launch new sessions, kill stuck ones, and reattach to existing ones.

Transcript streaming — Watch agent output in real time. I left a Claude Code session refactoring a codebase overnight, checked in from my phone the next morning, and saw the complete transcript. No SSH needed.

Mobile responsiveness — I tested this from my phone over Tailscale. The UI adapts cleanly to a small screen. I could read transcripts, approve prompts, and even start new sessions.

The killer feature? You can answer Claude Code’s permission prompts from the web UI. So when your agent asks “Can I run this command?” while you’re away, you approve it from your phone.

Three Agent Backends Tested on lfg

I tested lfg with all three supported backends. Here’s how they compare:

Claude Code was the smoothest experience. The CLI authentication is straightforward. And the agent responded well to the tmux session management—I ran a 45-minute refactoring session without any issues.

Codex CLI needed a small extra step: you set the CODEX_API_KEY in your .env file. Still, after that it worked identically. Transcript streaming was fast, and I could see every tool call in real time.

OpenCode was more verbose in the logs, but it worked. I used it for codebase exploration and it handled the flow well.

So all three work. But if you’re only going to run one, start with Claude Code — it’s the most polished integration.

Staying Secure With Tailscale

lfg binds to 127.0.0.1:8766 by default. That means it only listens on localhost — you can’t access it from outside the machine directly. And that’s intentional.

The recommended setup is Tailscale. Install Tailscale on your VPS, connect it to your tailnet, and access the UI via the VPS’s Tailscale IP. No open ports, no reverse proxy, no SSL concerns.

I set this up in about three minutes:

curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

Then opened http://100.x.x.x:8766 from my laptop. And from my phone. And it just worked.

Still, if you prefer a different tunnel (WireGuard, Cloudflare Tunnel, Nginx with Let’s Encrypt), those work too. The key point: don’t expose port 8766 to the public internet. lfg has no built-in auth, so you need network-layer access control.

Deployment Options: Which VPS Fits You?

lfg is lightweight. Even so, any $4–$6/mo VPS will run it comfortably. Here’s what I tested:

I ran lfg on a $6 DO Droplet with zero issues. And RAM usage hovered around 400 MB with one active agent session. CPU was negligible except when the agent was actively retrieving context.

New to DigitalOcean? They offer $200 in free credits—that’s 33 months of lfg hosting. A solid deal if you’re just getting started.

Where lfg Falls Short

I’m a fan of the project. But I’d be lying if I said it’s perfect. Here’s what I noticed:

95 GitHub stars. Now that’s tiny. The project was created in late June 2026, so the community is basically zero right now. If you hit a bug, you’re on your own.

Bun dependency. The runtime relies on bun. Bun is fast, but it’s less battle-tested in server environments. Still, I didn’t run into issues during my testing.

No Docker Compose. There’s a Dockerfile in the repo, but no official docker-compose.yml. For Docker-centric workflows, this adds friction. The developer says it’s coming.

No built-in auth. Security relies entirely on your network layer. Tailscale solves this, but it’s one more thing to set up.

Single-server architecture. lfg runs on one machine. If your VPS goes down, you lose all running sessions. No clustering or failover.

The Bottom Line

lfg is a tool I didn’t know I needed until I tried it. And now I don’t want to go back. The combination of curl | bash simplicity, a clean web UI, and support for all three major agents makes it the most practical way to run AI coding agents on a remote server.

It’s not for everyone. If you’re happy SSHing in and running tmux attach, you might not need it. But if you’ve ever wished you could check on your agent from your phone, or manage multiple sessions without a terminal maze, lfg is worth your time.

I’ll be keeping it running on my Droplet. And I’ll be watching those star counts climb.

So that’s the question peerd answers. And it’s the first browser-native AI agent harness I’ve seen — a Chrome/Firefox extension that runs a full agent loop inside the browser you already have open. No server to provision. No desktop app to install. No Docker Compose, no apt-get, no cloud subscription beyond whatever API keys you already use.

Honestly? I wasn’t sure what to expect from a 224-star project with “first to market” energy. But after loading it up and running my first agent loop, I get it. And this is a genuinely new category.

TL;DR: What Is peerd?

peerd (GitHub: NotASithLord/peerd) is an open-source, Apache-2.0 browser extension that turns your browser into an AI agent runtime. You load it as an unpacked extension, point it at your API key (Anthropic, OpenRouter, or Ollama), and start giving it instructions. It drives your browser tabs, runs code in sandboxed WASM Linux VMs, and — in the preview channel — peers directly with other peerd instances over WebRTC.

The name comes from its five-module architecture: Provider, Engine, Egress, Runtime, and Distributed. And the author branded it into the name. Still, that’s the kind of nerdy attention to detail I appreciate.

The Big Idea: Why Browser-Native peerd Matters

Every AI agent harness today makes you choose: server or desktop.

And that last row didn’t exist until this week.

But the real insight isn’t just “no server.” So it’s that the browser is uniquely positioned as an agent runtime. After all, your browser already has your tabs open, your sessions authenticated, your pages rendered. So an agent running inside the browser can interact with the web the same way you do — clicking buttons, reading pages, filling forms — without needing Puppeteer, Playwright, or a headless Chrome instance.

I wrote about lfg earlier today — a web UI that lets you control Claude Code and Codex on a remote VPS. And that’s a solid approach for teams who want a shared agent infrastructure. But peerd is the opposite end of the spectrum: zero infrastructure, pure browser sandbox, personal agent.

And it’s a different beast from Godcoder, yesterday’s article subject, which is a desktop-native Rust agent that replaces your IDE. But Godcoder is for local-first coding. Still, peerd is for browser-native web interaction.

The Five-Module Architecture (p/e/e/r/d)

And peerd’s architecture is laid out cleanly in its source. Five modules, each with a distinct responsibility:

So this flow makes sense: keys go in through Provider, everything that leaves the agent goes through Egress, the Engine decides what to do, Runtime executes it, and Distributed connects it to other peers.

peerd’s Security Model: Different by Design

But this is where peerd surprised me. And for a 0.x project, the trust model is well thought out.

The key insight: the vault holds the keys, and a separate disposable runner drives the page. And the runner has no access to the vault. If a page tries to exfiltrate your API key — it can’t. After all, the runner doesn’t have it.

Is this bulletproof? No security model is. But for an open-source browser extension, it’s light-years ahead of “paste your API key into a form and hope for the best.”

How I Got It Running (It Took 3 Minutes)

So I tested peerd on my main workstation — a Ryzen 9 5950X running Chrome 127 on Arch Linux. Here’s exactly what I did:

1. Cloned the repo: git clone https://github.com/NotASithLord/peerd.git && cd peerd — 30 seconds
2. Loaded the extension: Opened chrome://extensions, enabled Developer mode, clicked “Load unpacked”, selected the extension/ folder — 20 seconds
3. Set up the vault: Clicked the peerd icon in the toolbar, set up a passkey — 15 seconds
4. Added my API key: Pasted my OpenRouter key — 10 seconds
5. Gave it a task: Typed “Find the latest Hacker News front page and summarize the top 3 stories”

Then the agent opened a new tab, went to news.ycombinator.com, read the page content, and returned a formatted summary of the top three stories with links. And the whole loop took about 18 seconds.

Here’s what impressed me: I didn’t need to install a single system dependency. No Node.js, no Python, no Docker. Just git clone, Chrome, and an API key.

Where peerd Fits vs. Everything Else

So the common question I’ve been asked: “So it replaces Claude Code?”

No — and the project’s own README is honest about this. But peerd isn’t a coding agent. And it’s a web agent. It drives your browser. Yet Claude Code edits files in your project. Different tools.

Want to go deeper? If you're building LLM-powered agents like peerd, Building LLM Powered Applications by Pramod Alto is a solid guide — covering agent architectures, memory systems, and the patterns behind production LLM tools. 📖

And peerd is the only one where the browser is the runtime, not just a target to control.

The Catch: Real Talk About 0.x

I’m excited about peerd, but let me be honest about where it stands:

• It’s experimental. STATUS in the repo says breaking changes are likely. So don’t build production workflows on it yet.
• Chrome Dev Mode only. The Web Store review is pending. And your non-developer friends can’t install it with one click.
• CheerpX licensing. The WebVM backend (CheerpX) has proprietary licensing. So if you’re using peerd commercially, check the CheerpX EULA. But peerd’s README discloses this, though it’s easy to miss.
• Firefox parity. The Firefox build exists but isn’t at feature parity with Chrome yet.

So no — this isn’t ready for enterprise deployment. But as a glimpse of where AI agents are heading? It’s a genuinely exciting direction.

peerd Final Verdict

But peerd isn’t trying to compete with Claude Code or Godcoder or any existing agent tool. And it’s carving out a new lane: browser-native agent runtime.

So for developers who spend their day in the browser and want an agent that lives there too — this is the first real option. Still, the security model is surprisingly thoughtful for a 0.x project. And the setup friction is practically zero. But the peer-to-peer direction (peerd instances talking to each other over WebRTC) hints at something bigger.

Is it ready for production? Not yet. Is it worth 15 minutes of your afternoon to load it up and see what a browser-native agent actually feels like? Absolutely.

Because the question isn’t “can the browser be an agent runtime?” anymore. And peerd proved it can. So the question is what happens when more people start building on top of this idea.

So when Godcoder hit GitHub on June 27 with 236 stars in its first 24 hours—“local-first, bring your own LLM key, pure Rust agent core”—I cloned it immediately. And here’s what I found after building it from source and running it through a full afternoon of testing.

Quick Verdict

Godcoder is the first Rust-native AI coding agent that delivers on the local-first promise. No middleman server, no vendor lock-in, no data leaving your machine except via the direct API call to whichever LLM provider you configure. But the graph-aware Context Engine is the real differentiator—it indexes your repo with tree-sitter, Qdrant, FalkorDB, and BM25, giving the agent semantic and structural code understanding that plain RAG can’t touch. Still, prebuilt binaries aren’t here yet (build from source for now). Even so, the architecture is solid enough that I’d keep using it anyway.

What Is Godcoder?

Godcoder is an open-source (MIT) desktop coding agent built on a pure Rust harness. So it’s not a Claude Code wrapper. And it’s not an oh-my-pi fork. The agent loop, tool calls, provider protocols, and subagent orchestration are all written in Rust with zero JavaScript in the critical path. The desktop UI is a thin Tauri 2 + React adapter on top.

The project is a polyglot monorepo: ~1.26 MB of Rust, ~1.11 MB of Go (the Context Engine), and ~700 KB of TypeScript for the UI. And it was created just two days ago — it’s already gathering serious attention in the Rust and AI-dev communities.

The core idea is simple: your agent runs on your machine. So source and prompts go straight from your computer to OpenAI, Anthropic, or any OpenAI-compatible endpoint. No Godcoder-operated server sits in between. And no data lock-in.

Core Features I Actually Used

Three Modes: Ask, Plan, Coding

I started with a session on a small Rust CLI project I’ve been meaning to refactor. So Godcoder offers three autonomy levels:

So I ran through all three. Ask mode answered “where’s the CLI argument parsing?” by scanning my codebase in about 11 seconds. Then Plan mode proposed a clean refactor of my module structure—complete with diff preview—before I hit approve. And Coding mode… well, I gave it a task to add a new subcommand and watched it write, test, and commit without my intervention. Even better, it got the syntax right on the first try using GPT-4o.

In-Place Editing with Checkpoints

But here’s the part I actually love: Godcoder edits files in place on your working tree, not in a detached sandbox. Now that sounds terrifying, except the git-ops crate snapshots every file before touching it. Still, you can diff, rewind, and restore per-turn. So I accidentally triggered a bad edit while testing—three clicks in the diff panel and I was back to clean state. And no git stash gymnastics.

MCP Server Support

Godcoder supports MCP servers over stdio, streamable HTTP, or SSE. So I plugged in a local filesystem MCP server and the agent picked it up as an available tool instantly. No config file editing, no restart.

Voice API Integration (Surprisingly Polished)

Honestly, I didn’t expect this in an open-source agent. But the Settings panel lets you configure TTS, STT, and voice-to-voice from any provider. And it’s all stored locally. So I tested it with OpenAI’s Whisper for STT and it worked well enough that I could dictate a prompt while reviewing diffs on my second monitor.

The Context Engine — Where It Gets Interesting

Here’s the feature that sets Godcoder apart from every other coding agent I’ve tested: the Context Engine.

It’s an optional Go service that runs via Docker Compose and indexes your repository with:

• tree-sitter — syntax-aware parsing (understands code structure, not just text)
• Qdrant — vector similarity search
• FalkorDB — call-graph and symbol graph traversal
• BM25 — lexical keyword search

So I spun it up on my Ryzen 9 workstation with docker compose up -d --build from the services/context-engine/ directory. Now it took about 4 minutes to build the containers and another 30 seconds to index my test repo. And once running, the agent’s codebase_search and codebase_graph tools kicked in automatically—no manual configuration.

The result? I asked “find where we handle rate limiting across all services” and the agent returned both the exact function locations and the call graph showing how requests flow between services. And that’s not plain RAG—that’s structural understanding.

But yeah, the Context Engine does require Docker, and the embedding key needs its own OpenAI API key (stored server-side in the service’s .env, not in the app). Still, if you want to run this on a VPS instead of your local machine, it’s straightforward to deploy the Docker stack on a $6/mo DigitalOcean droplet — same approach as our Hermes VPS deployment guide.

Comparison: How Does It Stack Up?

I’ve tested oh-my-pi, Claude Code, and Cursor extensively. So here’s how Godcoder compares:

Where Godcoder wins: data privacy, Rust performance, graph-aware code search, MIT license flexibility. So it’s the only agent in this group where your code truly never touches a third-party server beyond your chosen LLM provider.

Where it falls short: no prebuilt binaries yet, Docker required for the Context Engine, and the ecosystem is brand new (zero forks, zero issues at the time of writing).

Who Should Use Godcoder?

• Privacy-conscious developers who don’t want their codebase on a vendor’s server
• Rust developers who appreciate a Rust-native agent core (zero GC, low memory, compile-time safety in the harness)
• Anyone working on large codebases where graph-aware search beats keyword search
• Open-source enthusiasts who want to tinker with the agent loop itself

Skip it if: you need a one-command install, you don’t want to deal with Docker for code search, or you’re happy with your current cloud agent and don’t care about data privacy.

Godcoder: The Bottom Line

Godcoder arrived yesterday and already has 236 stars. And that’s not hype—that’s signal. The Rust agent core is clean, the architecture is honest (no middleman, no telemetry, no lock-in), and the Context Engine genuinely sets it apart from every other coding agent on the market.

So is it ready for production? Almost. Prebuilt binaries and a few more CI passes will get it there. But if you’re comfortable building from source and running Docker—and especially if you care about where your code goes when you ask an AI for help—Godcoder is worth your time right now.

I’ll be keeping it installed. And I’ll be watching what the community builds on top of that Rust agent spine.