Press enter or click to view image in full size
I have been curious about the pi coding agent since I became aware of it a few weeks ago. Lately my daily driver has been OpenCode, and I’ve invested some time into building workflows around it, so while the idea of a minimal agent focused on extensibility over a structured, heavy, “batteries included” tool was appealing, the idea of losing productivity to learn a new tool was holding me back.
That changed when I decided to try giving fully local agentic coding an honest try, and set up a home LLM server to work with. One of pi’s selling points is that it’s extremely light-weight and context efficient, especially compared to OpenCode which adds around 14k tokens to your context by default before you make the first keystroke. Since context tokens are precious when you only have 32GB of VRAM, this seemed like the perfect excuse to finally give pi a try.
So after installing pi and hooking up my local llama.cpp endpoint (running Qwen 3.6 27B Q4), I played around a bit generating funny interactive single-page websites just to get a feel for the tool. Initial impressions were good. It felt a bit more conversational than OpenCode, and the results were good with the raw model, without adding any extensions, or even writing an AGENTS.md, so I decided to go ahead and try to build something a bit more serious.
I thought I would try to use pi to build a tool I’ve been thinking about in recent days. It would be a relatively simple React application backed by a Rust server running locally.
I spent a little time creating some context for the project. First I created a short AGENTS.md to give general guidance on the project layout and workflow. Then I created a product.md and architecture.md to describe the product concept and give direction for how I wanted things laid out from a technical perspective.
Once I was happy with the setup, I launched pi and gave it it’s first task. I wanted to start simple, so I asked it to go ahead and initialize the crate for the Rust server with some dependencies I knew I would need. The first result was not great, as it picked older versions for the dependencies. This made sense, since so far pi had no way of accessing the internet, so probably it was picking versions from whenever the training data was cut off.
To solve this problem, I installed extensions for web search, and MCP support. I also installed ponytail as it seemed like a sensible way to bias results towards more minimal solutions. Then I made a note in the AGENTS.md to always check for the most recent version of any dependencies it was adding to the project, and asked the agent to set up the crate again.
This time, it did the web search and arrived at the correct package versions. But when it tried to verify using cargo check, it ran into a version conflict in one of the dependencies. The offending crate was actually my own type_reflect, which I include to bridge types in basically every project where I bridge Rust and typescript or python. Apparently one of type_reflect’s dependencies relied on an outdated version of serde which was incompatible with another dependency.
The issue seemed clear enough, so I spent about 10 minutes manually updating type_reflect, got the tests passing, and pushed a new version to crates.io. I told the agent that I had updated the crate, and instructed it to update the dependencies and try again. So it went ahead and found the latest version, updated Cargo.toml, and checked the dependencies again. Apparently I had missed a detail, and there was still an issue with the dependencies.
But this time it didn’t stop there. Now that it was aware that this was my crate, it went ahead and cloned the repo into /tmp and got to work fixing the issue. At this point, I wasn’t quite sure what the agent was trying to do. Was it going to find the solution and tell me how to fix it? Was it going to vendor the crate, so my project would depend on a patched local version? Was I witnessing the limitations of a smaller model, and Qwen 3.6 27B was just confused? I wanted to see what the model would come up with, so I decided to let the agent run to see what would happen.
To my surprise, the agent went ahead and verified the fix against the project I was working on, and then proceeded to push the changes to github, and publish a new version to crates.io. Here’s the commit.
In retrospect, this makes perfect sense as a way to solve the problem. It’s what you might expect another engineer on your team to do if they ran into this issue. But it went against my naive assumption that the agent would try to stay within the bounds of the project, or at least ask for approval before doing something like making changes to published software I own.
On the one hand, this was pretty impressive. I’m still in the process of testing out the capabilities of Qwen 3.6 27B, and even though there’s a lot of positive buzz around the model, I wasn’t sure how it would stack up against state-of-the-art alternatives like Fable or even Opus. So the fact that it was able to conduct this relatively complex task spanning multiple projects, leveraging tools like git and crates.io in the same way I would have done, with no guidance and barely any context, gives a good first impression of the tool’s capabilities.
At the same time it’s terrifying. This was my first time witnessing first hand an agent doing something unexpected with a real-world outcome in pursuit of a goal. This time the outcome was well-aligned with my own goals, but what if the model decided it was a good idea to delete the main branch, or delete files off of my computer? What kind of damage could be done by an agent swarm looping overnight if someone leaves the wrong door open by mistake?
I went into this experiment with the knowledge that pi is fundamentally unsafe out of the box, but it just goes to show how something seemingly innocuous, like creating a simple Cargo.toml can have unexpected consequences. And like how you have to assume that every line of code that can be executed will be executed at some point, you have to work under the assumption that an agent will do anything it’s not prevented from doing.
Even so, I had a good first impression of pi + Qwen 3.6 27B as a powerful coding tool, and I intend to keep using this combindation to see how far I can take it. But my next task will definitly be to figure out how to set up some sensible guard-rails.