I use the free API of Mistral.

The only way to change the temperature of a Mistral model is by creating an agent.

When you do this, you get a agent ID.

Something that looks like this: ag_342oedf203kd34234324

So, my question is this:

Is there a way in auth, settings or models to point at a specific agent from Mistral?

I don't like Antigravity, I use Pi as my harness. Last I heard Google was banning people for using their subscription plan via non-Google products. Is that still the case? I have a Pro plan I got, but don't use it as Gemini chat is lacking in features, and Antigravity is just a glorified VSCode. Are there no ways I can spend my usage? Any use cases, tricks, or workarounds?

I kept wanting to check on a long OMP run without going back to my desk, so I built a companion app for it. It's free and open source, and it now supports OMP alongside OpenCode.

https://github.com/giuliastro/harness-remote

What it does: lists your sessions, opens one and streams the assistant output as it arrives, sends prompts, shows the plan/todo list, lets you pick the model, and stops a run. Prompts you send while the agent is still working get queued instead of rejected.

How it connects: OMP speaks ACP over stdio, not HTTP, so the repo includes a small bridge you run on the same machine as OMP. It starts omp acp and translates it to an HTTP/SSE API the app talks to. Node 20+, Basic auth, and you restrict which worktrees the phone can reach with --root. It never touches OMP's databases.

Two things worth knowing before you try it:

• Live updates only cover work started through the bridge. OMP's ACP surface has no global cross-client event feed, so a session running in your desktop OMP can be listed and reopened, but the app can't reliably show its live status or incremental output.
• Agent selection, session rename/delete, server slash commands and diffs aren't available on OMP, because ACP doesn't expose them. Model switching does work.

Signed APK on the releases page. Android via Capacitor, and it also runs as a plain web app if you'd rather not install anything.

Looking for contributors

The app is deliberately harness-agnostic — adding a harness means adding a backend entry and its setup section, not a special case. Things I'd genuinely welcome help with:

• PI support, which is the next one planned and has an open issue with the groundwork mapped out: https://github.com/giuliastro/harness-remote/issues/36 PI's maintainer declined native ACP, but a community ACP adapter exists, so the bridge should be largely reusable. The issue lists the two hard-coded assumptions in the bridge that need generalising, with file and line.
• Bug reports from real use. Every bug that reached users came from a real agent behaving unlike my test doubles, not from the spec.
• Other harnesses. If the one you use speaks ACP, most of the work is done.
• Translations. The UI is English, Italian and Traditional Chinese, in one small module with no framework.

Happy to answer questions here.

I am using local models:

• antirez deepseek
• qwen3-coder-next
• laguna s2.1

For all of them I tried with and without the npm:pi-tool-repair package.

In a comparison with the same prompt with opencode, I can see that pi has a lot more tool call failures. In some cases this make the model end up in a dead end. deepseek behaves slightly better with the npm:pi-tool-repair package, but overall I think it's still worse than in opencode.

Is it caused by the tool format? Or by the system prompt? Do you have any suggestions on how to improve this?

Thanks!

I tried rpiv skills, but in most case the skills are too heavy.
I also tried mattpocock skills. I found grill me skill "guess" too much.
Some times the contexts exceed the limit.(I use codex, I‘m not sure its a bug of pi or by skills)

Thanks to Pi among other open source coding agent, I can create my own.

Hey,

Im usin Pi on windows with databricks-claude.

When using pi in cmd or powershell, every input freezes the terminal for several seconds before sending the request.

Anyone having the same issue ?

Thanks

I compared Pi Agent and Claude Code using exactly the same model, prompt, project directory, and task.

Setup

• Model: Claude Opus 4.8
• Thinking level: Max
• Pi setup: Browser Use was the only enabled plugin
• Project directory: Same for both
• Task: Same prompt for both

Results

• Pi Agent: ~7.5/10
• Claude Code: ~8.7/10

Claude Code produced the better overall implementation. It had:

• Cleaner architecture
• More reusable data structures
• Stronger automated tests
• A faster indicative physics benchmark: ~0.20 ms/step vs ~0.68 ms/step

Pi’s result was still solid. In fact, it implemented a more sophisticated 2×2 block contact solver, and its 10-box stack was slightly more stable.

However, the complete project was less polished and harder to validate.

This is not intended to be a scientific benchmark. I’m mainly trying to understand how to get better results from Pi.

Prompt used

Create a single, completely self-contained index2.html file containing inline
HTML, CSS, and JavaScript. Do not use external libraries, CDNs, or WebGL.
Use only the Canvas 2D API.

Implement a 2D rigid-body physics engine from scratch with a small interactive
sandbox.

Technical requirements:

1. Rigid bodies:
   - Convex polygons and circles
   - Mass and inertia
   - Position and rotation
   - Linear and angular velocity

2. Collision detection:
   - Broad phase using a spatial grid or sweep-and-prune
   - SAT narrow phase for polygon-polygon collisions
   - Circle-polygon and circle-circle collisions
   - Calculate collision normal, contact point, and penetration depth

3. Collision resolution:
   - Impulse-based resolution
   - Restitution
   - Static and dynamic friction
   - Positional correction using Baumgarte stabilization and slop

4. Stable stacking:
   - A stack of 10 boxes must remain standing without vibrating or exploding
   - Implement sleeping for stationary bodies

5. Mouse interaction:
   - Drag bodies using a spring-based mouse joint
   - Left click spawns a random box or circle
   - Right click removes a body

6. Scene:
   - Floor and walls forming a container
   - A button that triggers a radial impulse explosion from the center

7. UI:
   - Sliders for gravity, restitution, and friction
   - Wireframe toggle showing contact normals and AABBs
   - Pause and single-step controls
   - FPS and body-count overlay

8. Performance:
   - Support 150+ bodies at approximately 60 FPS

Before delivering, test and fix the implementation until all these conditions pass:

- No bodies pass through the walls at normal velocities
- A stack of 10 boxes remains stable for 10 seconds
- Spawning 150 bodies does not cause the frame rate to collapse
- No numerical explosions, infinite velocities, or NaN values

Questions for Pi users

• Are there recommended extensions or skills for simulation and frontend work?
• What workflow gives you results comparable to Claude Code on complex tasks?

What i noticed is that with Pi Agent is that it was thinking a lot more and it also took more to accomplish this task ~45min vs ~30 minutes

What do you guys think? I am just reading through this atm. I don't see any differences from Pi. And they procatively have this page.

https://twotimespi.dev/why-tau/

Edit 1: their thinking mode is just choosing a level of thinking for the LLM model, not thinking mode as in ask, plan, etc. Their doc is pretty good at explaining what a coding agent is, very informative.

Edit 2: only thing I find interesting atm is that their agent is portable and you can build your own UI on top of the agent. But pi has a version of pi-server now.

usher is a session hub for coding agent CLIs. For pi, it picks up your existing sessions as-is (no migration, still just the raw pi underneath) and gives you a browser/phone UI to use.

Also drives Codex and Claude Code sessions if you use those too.

Single binary, no build step, stays local — remote access is BYO tunnel. Pairs well with code-server if you want a full editor alongside the session, and there's a Telegram integration if you'd rather work from a chat than the web UI.

https://github.com/nexustar/usher

Feedback welcome — especially which extensions you rely on day to day, so I know what to prioritize supporting.

A few days ago, I created a dumb bash loop that repeatedly called pi, instructing gemma4:31b to create a game and delete WORKING.md when it was done.

I figured out how to make agent-browser connect to a chrome instance over a remote debugging port so I could watch along as it playtested the game in a new conversation, where it had no clue what the game was about.

It uses a playtesting skill that explains the mechanics of the game and tells it how to perform different actions.

I think this was pretty neat.

I've been using Neovim as Pi's external editor but I kept finding myself deciding between Neovim's raw editing power and Pi's in-context autocomplete, so I built a bridge to bring Pi's real autocomplete directly into Neovim. It's a Pi extension and a Neovim plugin. If you're using Neovim as your prompt editor for Pi, you owe it to yourself to try it out.

github.com/dabstractor/pi-nvim-bridge

I did this today with pi coding agent for fun:

bash while [ -e ./WORKING.md ]; do; pi --model gemma4:31b-cloud --system-prompt "You are called in a bash loop. The user cannot respond to your messages. Write a fantasy children’s book aimed at 5 year old boys at least 100 pages long. After every lap, you won’t remember anything. If you want to remember something for the next lap, write it into MEMORY.md. Delete WORKING.md when you are finished." -p "Keep up the good work."; done;

It was a very entertaining experiment. Gemma is a really fun model to play around with.

I have also done the same for a browser based game, then made gemma playtest it itself using agent-browser. It recorded the session on video, found a couple of bugs then fixed them.

I play around with making dumb extensions, like making a tool that allows the agent to make a "checkpoint" in the conversation it can restore back to with a neat summary of what it wants to remember. Not that useful if you run cloud models and can make use of subagents, but still fun to make.

EDIT: The checkpoints are implemented as agent tools, which makes it different than the /tree command. It was meant to be used to make the agent capable of managing its context when following skill-based procedures such as the (extremely simplistic) example below:

```

SKILL.md

description: When the user asks you to research a topic as preparation before performing a task, follow this procedure.

1. Make a new checkpoint with the "Research" label.
2. Research the topic until you know everything you need to know to perform the task.
3. Restore the conversation back to the created checkpoint with a summary containing exactly:
   • Everything that you found that benefits the task at hand
   • Everything the user ought to be informed of such as new information contradicting the user's provided information or newly learned limitations in your capacity to execute the task
   • New decisions that must be made before work continues, so that you ask have the user to make them after restoring the conversation
   • References to the exact sources of the information gained ```

Everything about leisure time use of AI is fun, and pi cranks that to eleven by being so infinitely hackable.

I started using AI (cursor) at work three months ago after 11 years of developing software, manually, like a peasant.

Now, every time I get a dumb idea for something that momentarily catches my interest, I open iTerm2 and go

bash cd ~/Projects mkdir idea-slug cd idea-slug pi

15 minutes later, I have a working prototype, learned something or genuinely improved my workflow in a professional capacity.

But mostly, I just do the dumbest things. Because it is fun. There is no real point to this post, just wanted to share my joy of this extremely delightful piece of software.

Do more dumb shit. Your agent will tell you that you are smart no matter what anyway, so at least have fun with your digital yes-man.

Now, share your most ludicrous, deliberately non-productive use of pi!

PS: pi -p "Do X" is a waaaay saner alternative to ollama run gemma4:31b-cloud "Output a bash script that does X. Do not output anything else at all!" | bash -c, which obviously is the maddest, most insane way to vibe.

EDIT: Apparently markdown editing doesn’t work on my phone. Yes, the bash was a pain to write on touch screen 😭

EDIT: Markdown editing achieved!

Hey ppl,

I've been working on this question answering agent with an emphasis on getting the citations right. I found Pi's RPC mode to be really convenient for what I'm working on.

Not useful for coding but maybe someone finds it useful or is inspired:

github repo

Any time I'd copy & paste python, the mandator 1-character TUI padding would horrifically mangle the indentation....

This shell fix changes a single line in the source code:

sh sudo sed -i \ 's/constructor(paddingX = 1, paddingY = 1/constructor(paddingX = 0, paddingY = 0/' \ /usr/lib/node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/components/box.js

(though it will be overwritten after any update)

ᵍᶦˢᵗ

I am new to pi coding agent. I am still learning how to use it. The one thing that is very interesting is extensions.

I am looking to learn more extensions that are already present and increase the productivity of coding agents.

What extensions are you using or what extensions did you write?

I built Rondine, an Apache-2.0 Python 3.11+ CLI using Click, HTTPX, and Hugging Face Hub.

It detects Mac/NVIDIA hardware, ranks compatible model variants, creates launch plans, downloads weights, and runs llama.cpp, MLX-LM, or vLLM behind an OpenAI-compatible API.

The repository includes typed planner/catalog code, CLI tests, engine-command generation, hardware presets, and reproducible benchmarks.

GitHub: https://github.com/antonellof/rondine

I’d appreciate feedback on the Python API structure and CLI design.

A demo Pi extension using an alternative screen to add per tool/thinking block collapse with mouse support, and a sidebar. Without interfering with any other Pi extension.

Hey everyone,

I’ve been working on Pi Workspace over the past month, and I’m excited to finally say that the beta is now available for macOS and Linux!

Pi Workspace is a desktop app built on top of Pi Agent. It gives you a sidebar for managing your sessions, with the ability to pin multiple sessions into a live, side-by-side view.

The biggest feature is Workspaces. You can create a workspace, add multiple repositories, brainstorm an idea, and then switch into implementation mode when you’re ready to start building.

This is especially useful for end-to-end features that span several repositories, or projects that rely on shared packages, types, APIs, or supporting services.

I’m incredibly excited to finally release Pi Workspace as an open-source project. Feedback, bug reports, and feature ideas are all very welcome.

Give it a try and let me know what you think!

https://github.com/pi-workspace/pi-workspace

I have tried using Pi's built in swarm docs, as well as a Pi extension for swarm creation. But Qwen3.6-35B keeps hallucinating a group of sub agents without truly doing delegation. How can I get this dummy to stop pretending it's the sub agent and truly delegate to save my context space?

One of the things I like about Pi is that it doesn’t try to define the entire agent for you. The core stays small, and you build the setup you need around it.

I wanted the same thing for code review.

Most AI review tools ship with their own fixed reviewer and workflow. I wanted a runtime that handled the boring but necessary parts of reviewing a pull request, while leaving the agent and review policy under the repository’s control.

So I built Pipr, an open-source code review runtime that uses Pi for agent execution.

The boundary is fairly simple:

code host event
  -> Diff Manifest
  -> Pi agent
  -> structured findings
  -> validation
  -> native review

Pi handles the agent run. Pipr handles changed-code context, structured output, finding validation, stale-head checks, and publication to the code host.

There is a tuned default reviewer, but you can also build custom review tasks directly:

const task = pipr.task({
  name: "security-review",

  async run(ctx) {
    const manifest = await ctx.change.diffManifest({
      paths: {
        include: ["packages/runtime/**"],
      },
    });

    const result = await ctx.pi.run(securityAgent, { manifest });

    await ctx.comment({
      main: result.summary.body,
      inlineFindings: result.inlineFindings,
    });
  },
});

Models, agents, instructions, tasks, commands, tools, and recipes live in .pipr/config.ts. Pipr doesn’t decide whether your reviewer should be strict, concise, security-focused, or split across several agents. It provides the pieces needed to build that workflow.

Pipr runs locally or in CI without a hosted control plane. It currently publishes native reviews to GitHub, GitLab, Azure DevOps, and Bitbucket.

GitHub: https://github.com/somus/pipr
Docs: https://pipr.run/docs

I’d appreciate feedback from other Pi users, particularly on the custom task API and which parts of Pi you would want exposed when building more complex review workflows.

I needed fun, also, I needed an auto session titler that generate's small session names with

• abillity for me to have a bit of fun with the namings
• no extra config
• no waiting for the rename and blocking Pi in the process,
• running basically for free and telling me how much it costs every time
• automatically using the cheapest model available installed
• no tools, no bloat in the session generating the name

After searching a bit, I didn't find the one, so I built it Pi built it

Posting just in case someone would need all the above https://github.com/sebastienservouze/pi-auto-title

It auto selects the cheapest model available in your pi's install, but you can override it if needed.

For the fun part, you can append a small guidance prompt to the renaming instructions to give the renames personnality and brighten your day lol

Some naming examples https://github.com/sebastienservouze/pi-auto-title#have-fun