Jul 25, 2026 · 6 min read

I Used Poolside for a Week — The Coding Agent That Trains on Its Own Code

This is week 17 of my “I Used It for a Week” series. I’ve tested Cursor, Kiro, Copilot, Windsurf, ChatGPT Plus, Devin, Claude Code, Aider, OpenCode, Antigravity, Continue.dev, Zed AI, Grok Build, Replit Agent, v0, and Bolt.new. This week: the coding agent that trains on its own code.

Poolside is different from every other AI coding tool I’ve used. It doesn’t just generate code and hope it works. It generates code, runs it, sees if it passes tests, and learns from the results. That’s what RLCEF means: Reinforcement Learning from Code Execution Feedback.

Their newest model, Laguna S 2.1, just dropped on July 21. It’s a 118B parameter MoE model that beats DeepSeek V4 Pro on Terminal-Bench while being 14x smaller. And you can run it on a single GPU.

After a week of using Poolside on real projects, I think it’s the most underrated open-weight coding model out there.

How It Works

Poolside has two ways to use it: their CLI tool called pool, or the API through OpenRouter. I used pool for the full week.

Installation is straightforward:

npm install -g @poolside/pool
pool

It drops you into a terminal session where you describe what you want in plain English. Pool reads your files, makes changes, runs commands, and iterates until the tests pass.

The key difference from Claude Code or Aider: Poolside’s models are trained with RLCEF, meaning the model learned from actually running code during training, not just reading static repositories. This should (theoretically) make it better at generating code that works on the first try.

Day 1: First Impressions

I opened a Python project and asked: “Add retry logic with exponential backoff to all HTTP requests in the client module.”

Pool read every file in the project, identified the HTTP calls, generated retry decorators with exponential backoff, added proper error handling, and then ran the test suite to make sure nothing broke.

Total time: about 4 minutes. It would’ve taken me 15.

The thing that struck me immediately: it didn’t just add the retry logic. It noticed I was using requests without session reuse, and refactored the HTTP client to use sessions while it was in there. That’s the kind of proactive improvement that comes from training on actual code execution.

Day 2-3: The RLCEF Difference

I asked it to fix a flaky test in my CI pipeline. The test was timing out intermittently — a classic race condition.

Pool didn’t just add a timeout increase. It analyzed the test, identified the shared state between test runs, added proper isolation, and then ran the test 10 times in a loop to verify it no longer flaked.

This is where RLCEF shines. The model has been trained on millions of execution cycles. It knows what flaky tests look like because it has seen the relationship between test code and test outcomes during training.

Day 4-5: Long Sessions

I gave it a big task: migrate a project from Flask to FastAPI. This involves rewriting route handlers, updating middleware, changing the ORM layer, and updating the test suite.

Pool handled it methodically. It proposed a plan first (which I could approve), then executed it file by file. It created the FastAPI app, rewrote each route handler, updated the imports, and ran the test suite after each major change.

The thinking mode was impressive. When it hit a tricky edge case with Pydantic validation that differed from Flask’s WTForms, it paused, thought through the differences, and found the right mapping. This took about 30 seconds of “thinking” before it produced the code.

The migration wasn’t perfect — it missed one endpoint that used a custom Flask decorator. But it was 95% correct and saved me about 3 hours of manual work.

What Blew Me Away

RLCEF training

The code that Pool generates is more likely to work on the first try. The execution-aware training means it has seen what happens when error handling is missing, when edge cases aren’t handled, when tests are incomplete. This shows up in the output.

Thinking mode

Laguna S 2.1 has a thinking mode that actually works. For complex tasks, you can see it reason through the problem before producing code. The thinking is coherent and productive, not just token waste.

Open weights

Unlike Claude Code or Cursor, you can download the weights and run Poolside locally. The 118B model needs about 80GB VRAM, but the smaller XS 2.1 (33B) runs on consumer hardware. For companies that need data privacy, this matters.

The trajectories

Every benchmark result Poolside publishes comes with full execution trajectories. You can see exactly what the model did, step by step. This transparency is unique in the industry.

What Frustrated Me

The terminal UI

Pool’s terminal interface is functional but basic. Long code blocks are hard to read. You can’t see diffs inline — you need to run git diff in another terminal. It’s better than Aider’s UI but worse than Claude Code’s.

Documentation gaps

The documentation is sparse compared to Claude Code or Cursor. Figuring out advanced features like thinking mode configuration or custom tool definitions took some trial and error.

No IDE integration

Like Aider and Claude Code, Pool is terminal-only. There’s no inline completions, no Tab suggestions, no gutter annotations. For quick edits, I still reached for Cursor.

Model selection

Currently you’re locked to Poolside’s models. There’s no option to swap in Claude or GPT for specific tasks. This is a limitation if you want to use different models for different tasks.

Poolside vs Claude Code vs Aider

Aider: Terminal-first, any model, git-native, cheapest. Best for developers who live in the terminal and want model flexibility.
Claude Code: Terminal-based but Claude-only, more autonomous, better at multi-step tasks. Best for complex refactoring and agent-style work.
Poolside: Terminal-based, open-weight, RLCEF-trained, thinking mode. Best for developers who want transparency and local deployment.

They’re complementary. My ideal setup: Cursor as my editor with Copilot for autocomplete, Claude Code for big tasks, and Poolside for tasks where I want open-weight transparency.

Would I Keep Paying?

Poolside is free on OpenRouter right now, and the weights are open. The paid API pricing ($0.10/$0.20 per 1M tokens for the 1M context endpoint) is competitive.

The real value is the open weights. If you need to self-host for data privacy, Poolside is one of the few options that gives you a competitive coding model you can run locally.

Rating: 8/10 — The RLCEF training difference is real, the open weights are valuable, and the thinking mode works. The UI and documentation need work, but the core product is strong.

FAQ

Is Poolside free?

Yes, currently. Laguna S 2.1 is free on OpenRouter through an unspecified period. The weights are open under OpenMDW-1.1 license. Paid API pricing is $0.10/$0.20 per 1M tokens for the 1M context endpoint.

Can I run Poolside locally?

Yes. Laguna S 2.1 is available on HuggingFace with BF16, FP8, INT4, and NVFP4 weights. You need approximately 80GB VRAM for the full model. The smaller XS 2.1 (33B) runs on consumer hardware with 16GB+ VRAM.

How does RLCEF training help?

RLCEF means the model learned from actually running code during training, not just reading static repositories. This makes it more likely to generate code that works on the first try, with better error handling and edge case coverage.

Is Poolside better than Claude Code?

It depends on your priorities. Claude Code is more polished and has better documentation. Poolside offers open weights, thinking mode, and RLCEF training. For local deployment and transparency, Poolside wins. For overall UX and ecosystem, Claude Code wins.

What is thinking mode?

Thinking mode lets the model reason through complex problems before producing code. It uses more tokens but produces better results for complex tasks. You can toggle it per session in Pool.

Next week: I Used MiMo Code for a Week — Xiaomi’s free CLI coding agent that’s challenging Claude Code.