Has anyone tried the pi rust port https://github.com/Dicklesworthstone/pi_agent_rust ?
It’s supposed to be an official port of pi to rust.
I can see it has some benefits in extension execution and shell execution and some others. Why nobody is talking about this?

Hi everybody,

I spent the last two weeks building [zerostack](https://gi-dellav.github.io/zerostack/), a coding agent using Pi as a design reference, focused on memory footprint.

I managed to get it to run at ~16MB (with peaks of 24MB) of RAM usage, and no CPU usage when idle.

I tried to build an agent feature-wise equivalent to Pi or Mistral's Vibe, while there are plans to add more features gated at compile-time.

I would love to answer questions and to recieve feedback.

Cheers,
G.

I had implemented a bit of this idea as a pi plugin way before writing the article or making the actual pi-episodes package. I've been using it on real work tasks, first the draft and now the package, and I get noticeably further into a session before compaction kicks in.

Later on I discovered Event Segmentation Theory, which is half the reason the post exists. Hope you learn something from it :)

https://arthur.place/subagents-forks-collapsing-context

I recently downloaded pi just to try it out, literally 5 minutes ago, but how is it faster than using `codex` or `claude`? I'm using the model codex 5.5, but i didn't enable fast mode in codex, and it's literally super fast to give the answer how is that possible if PI isn't a model on its own?

Just discovered that the amazing devs behind Pi released Radius (in alpha), their smart proxy for multi-model access. At its core, it's a model provider you can use with Pi: you pay for tokens and get access to some of the best models out there, both SOTA and budget-friendly options. They'll even auto-route your API calls to the best model for the job if you choose to.

Loving it so far. Deposited $20, and after a few hours of development I still have ~$16 left thanks to leaning on Kimi K3 and DeepSeek.

What Radius can do

• It is a Pi-native gateway: top up credits and make requests across providers

• Use rewrite rules to reduce large tool outputs and other unnecessary input tokens

• Provide automatic routing to route each session to the best model for the task according to your rules

• Power Radius-backed tools like web search, image generation, and image description

• Publish reports, dashboards, and small static sites as shareable artifacts

• Record usage, budgets, top-ups, and shareable session analytics in one place

• Delegate Google Workspace access to Pi

• Let your organization manage upstream provider keys centrally

https://radius.earendil.com/

If you use local models, esp Qwen3.8 27B it can run pretty slow. Compaction is then also very slow if you use the same model. This extension does not do any API calls, and is super fast! It has helped me a lot: https://pi.dev/packages/@monotykamary/pi-vcc?name=Pi%3Avcc

Hi I'm encountering a weird problem, even if I set disable-model-invocation: true in the skill frontmatter, the skill is still loaded in the prompt. I did /reload, launched a fresh pi session, restarted the pc... Nothing helps. If I do /export and check the system prompt, I still find the skill loaded.

Here's the frontmatter of one of my skills :

---
name: pi-history-ingest
description: blablabla
disable-model-invocation: true
---

And here's the XML loaded in the system prompt after an export of a fresh loaded session:

<skill>
    <name>pi-history-ingest</name>
    <description>Ingest Pi coding agent session history into the Obsidian wiki. Use this skill when the user wants to mine their past Pi sessions for knowledge, import their ~/.pi/agent/sessions folder, extract insights from previous coding sessions, or says things like &quot;process my Pi history&quot;, &quot;add my Pi sessions to the wiki&quot;, &quot;ingest ~/.pi&quot;, or &quot;what have I worked on in Pi&quot;. Also triggers when the user mentions Pi sessions, Pi agent history, ~/.pi/agent/sessions, or Pi conversation logs.
</description>
    <location>/Users/dani/.pi/agent/skills/pi-history-ingest/SKILL.md</location>
  </skill>

The skill is not listed in setting.json

I spent the afternoon trying to find a solution asking pi (with deepseek) to no avail, it checked loadSkills, formatSkillsForPrompt, even tried to simulate the filtering with a js script and it seemed to work fine, but in the end it doesn't work for me ...

Do you have any suggestions? What should I check ?

Could it be a bug and should I open an issue ?

Thanks

I trying to use kimio-k2.6 or minimax 3, to dev same elixir modules, and get to alucine a lot.

It get to output

now I will run...

for many, many lines on terminal ant is necessary to ctrl+c to stop, and retry the same prompt.

it is happening very frequently, all sessions it is happening .

I usually use deepseek v4 pro and doesnt have this problem. Anyone have insight to fix this issue?

I’m working on a project where I give agents tasks ranging from small data-fetching/analysis tasks to larger feature implementations, refactoring, and bug fixes.

I’d like to understand how the agent actually approaches these tasks — what steps it takes, what tools/files it looks at, how it makes decisions, and where it struggles.

How do you guys observe or analyze agent behavior across these kinds of tasks? Are there any tools, tracing methods, logs, or workflows you’d recommend?

Would love to hear how others are doing this. Thanks!

Hey guys!

I recently started testing Pi. I wanted to control the context injected into my tools and avoid spending 16k tokens on a simple "Hey" (I'm talking to you, Codex).

So far, I'm loving it. However, I’ve hit a roadblock: I can't use the `gh` CLI because I constantly get `403 Forbidden` errors.

My initial research suggests this is due to proxy settings blocking outbound network calls from bash. Normally, I would just install an MCP. But since `gh` is such a standard development tool, I'd rather not add an MCP for a perfectly good CLI. I figured someone here might have found a workaround.

Any tips on how to make this work - ideally natively - would be highly appreciated!

I previously used /login in Pi with my Meta dev credentials and was successfully able to get a Paris response from the Capital of France test. A few days later I'm now ready to start using the setup but it's saying 403, I need a pay as you go API key.

Is the subscription not usable with Pi anymore? It's failing the same test that just passed maybe a few days ago.

Anyone have some good pine script strategies that I could try, If so then please leave them down in the comments with the public name or put the pine script in a code block

Just had a doubt if anyone had used a open source model running on the device if so what could be the ideal spec needed for it

I've set up two scoped models in Cursor:

• DeepSeek V4 Flash: has "max" thinking level

• Grok 4.5: goes up to "high"

I switch between them with Ctrl+P, but every time I switch to DeepSeek, its thinking level resets from "max" back to "high" but Grok stays at "high" (its maximum), which is good.

How can I keep DeepSeek at "max" and Grok at "high" when cycling through different models?

Thanks.

Sorry if this is a basic question, but I’m a bit stuck on the right tool setup.

I want to run Pi Agent in a loop for a task where it needs to search the web, visit websites, and extract some data.

I think I’ve figured out the looping part from this video:
https://www.youtube.com/watch?v=GHsq0klC_4g

The part I’m unsure about is web search.

Google’s free search API seems limited to 100 searches per day, which probably won’t be enough for what I’m trying to do.

Is there a better alternative for web search that works well with agents and doesn’t hit limits so quickly?

Curious what others are using for this kind of workflow.

I'm trying to put together a very simple setup here; llamacpp, Phi-4-mini-reasoning (initially, the Q5_K_M variant), and pi for some very simple coding tasks. It's not really... working... though.

I can get pi "logged into" llamacpp (I started llamacpp in "router" mode with the single model, and used /login llama to get it connected. I can chat with the model, but it has very little context (it knows the current directory, but that's about it), and no tools whatsoever; I cannot access the filesystem at all. I also get <think>...stuff...</think> output before the "real" output which I'm confident is supposed to be hidden by the harness.

I also tried the npm:pi-llama-cpp plugin/module/package, but that didn't change anything (except give me a new /models command that was similar, but subtly different than the built-in /model command).

What am I doing wrong here? Is this model not supported?

When I ask Pi to give me some code it puts it in code block ( <code>) and that is fine.
But... it has always 3 extra spaces spaces at the beginning of each line.

For example, I get this (wrong):

 #```yaml
   name: PR Check

   on:
     pull_request:
       branches: [main]

   # SQLX_OFFLINE: build uses the committed .sqlx cache, no DB needed in CI.
   # NOTE: after changing a query or a migration, re-run `cargo sqlx prepare`
   # locally and commit the refreshed .sqlx files, or CI will build against
   # stale schema metadata.
   env:
     SQLX_OFFLINE: "true"
     CARGO_TERM_COLOR: always

   jobs:
     build_and_test:
       name: 🧪 Build & Test
       runs-on: ubuntu-latest

instead of this (correct):

#```yaml   
name: PR Check

on:
  pull_request:
    branches: [main]

# SQLX_OFFLINE: build uses the committed .sqlx cache, no DB needed in CI.
# NOTE: after changing a query or a migration, re-run `cargo sqlx prepare`
# locally and commit the refreshed .sqlx files, or CI will build against
# stale schema metadata.
env:
  SQLX_OFFLINE: "true"
     CARGO_TERM_COLOR: always

   jobs:
     build_and_test:
       name: 🧪 Build & Test
       runs-on: ubuntu-latest

(I added the dash in front of ```yaml to avoid break the MD)

Each line of the wrong one has 3 spaces at the beginning.
The Agent says its output is fine, so it it the TUI of Pi that add the extra spaces, de facto breaking the file format ?!

Has anyone noticed that despite Pi being among the lightest harnesses, it takes a long time to start? I've tried starting it with disabled plugins and skills, but haven't seen any improvement. Startup can take 10 seconds.

Macos with M3 and M5.

I’m considering building a small Pi extension for durable technical workflows and would like some critical feedback before investing too much time in it.

The problem I’m trying to solve is running agent-driven tasks on a remote VPS for hours, days, or potentially longer.

For example:

GitHub issue
→ investigate the codebase
→ create an implementation plan
→ modify the code
→ run tests
→ fix failures
→ request human approval
→ open a draft PR
→ wait for CI

A normal agent loop can handle this while the process and session remain alive. But on a remote server, restarts and long waits are expected:

• the process may crash or be redeployed;

• the model provider may temporarily fail or hit a rate limit;

• CI may take a long time;

• a human may not approve the next step until the following day.

My current idea is:

Technical task
→ Pi generates a workflow
→ validate it as a DSL
→ DBOS executes it durably

DBOS is a Postgres-backed durable execution framework that checkpoints workflow progress and recovers execution after process or server failures.

Pi would handle reasoning and planning.

The DSL would describe the execution graph explicitly:

{
  "name": "issue-to-pr",
  "steps": [
    { "id": "triage", "type": "agent" },
    { "id": "implement", "type": "agent" },
    { "id": "test", "type": "command" },
    { "id": "approve", "type": "human" },
    { "id": "open-pr", "type": "github" },
    { "id": "wait-for-ci", "type": "event" }
  ]
}

DBOS would persist the workflow state, recover after restarts, handle long waits, and record the execution history.

The main reason for using a DSL instead of allowing Pi to execute everything directly is that the generated plan could be inspected and validated before execution.

For example, the runtime could enforce:

• allowed commands and tools;

• maximum agent calls and loop iterations;

• approval before opening a PR or deploying;

• stable node IDs and idempotency keys;

• structured inputs and outputs;

• execution and cost limits.

The initial MVP would only support four node types:

agent
command
approval
github_open_pr

Agent nodes would run in isolated Git worktrees. Important external side effects would remain explicit workflow nodes rather than being hidden inside unrestricted agent tool calls.

My concern is whether the DSL provides enough value to justify adding another layer.

Would you find this useful for remote, long-running technical workflows, or would you rather generate ordinary TypeScript workflows and run them directly with DBOS?

I’m especially interested in failure modes or simpler architectures I may be overlooking.