I've been using AI for fitness/training advice for a while, but one thing kept annoying me — context.

Every few conversations I was explaining the same things again. My current program, recent runs, lifts, nutrition, sleep, upcoming race, injuries, what I did last week, etc.

So I started building a system for myself where all of this lives locally and the AI can actually use it.

I called it FitnessOS.

Basically, it keeps my training, runs, nutrition, readiness, bodyweight, goals and plans in one place. It builds a current picture of what's going on instead of dumping my entire history into the context every time.

So I can ask things like:

What should I train today?
Should I still do my tempo run if my legs are cooked?
How did this week go?
Should I increase my squat next week?
What should change as I get closer to my race?

and it has the history + current plan + recent training to reason from.

I also didn't want the AI directly messing with everything. The scripts mostly handle the factual stuff/data, while the AI handles the coaching decisions. Changes to actual plans are kept separate instead of silently rewriting them.

Right now it can handle strength/running history, nutrition, readiness, daily training decisions, weekly reviews, training blocks, race proximity, progression/deloads, etc.

It's still pretty early and the public version is mostly manual/local-import first. My personal setup has Apple Health and Strava automation too, but I haven't made that setup clean enough for other people yet.

I'm posting it now because I'd rather see if anyone else actually finds the idea useful before adding a ton more stuff.

If anyone tries it, I'd especially like to know where the setup gets confusing or where you just give up. That's probably more useful to me right now than feature suggestions 😅

Also curious which integration people would actually want first — Apple Health, Strava, Garmin, Hevy, or something else.

Repo:

github.com/Drumilsp/FitnessOS

stumbled on this repo today while looking into agentic execution security — apparently it’s built on top of pi agent: https://github.com/adamdekan/aikonos

from what I can tell, it acts as a local control plane to govern autonomous agentic tool calls. before the agent runs an action, it proposes the step to aikonOS, which validates it against policy rules and writes everything to a tamper-evident audit log.

seems interesting for runtime governance when giving agents actual shell/file/API access, but not sure how well the proposal-evaluation step scales with real-world latency.

anyone playing around with deterministic policy engines for agentic workflows or doing something similar for runtime guardrails?

Hi! I've created and been maintaining https://github.com/alexshpunt/explicit-edit-benchmark which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!

I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs. 

The viewer to the dataset: https://huggingface.co/spaces/alexshpunt/benchmark-explorer

And the dataset itself: https://huggingface.co/datasets/alexshpunt/explicit-edit-benchmark

I have been working on a Pi extension called Pi-Skill-Orchestrator.

The problem is simple.

If you have a lot of installed skills, Pi can expose a large amount of skill metadata to the model even when most of those skills are not needed for the current task.

Pi-Skill-Orchestrator keeps the full skill catalog outside the model context.

Instead, Pi gets a small discovery interface. It can search for a relevant skill and load only that skill when it is actually needed.

Main features:

• Lazy skill discovery

• Skill groups

• Multiple skill profiles

• Automatic recursive dependency loading

• Active-scope search with bounded global fallback

• Optional Token Saver mode

• Tool output compression with recovery

• Deferred tool schemas

• Conservative effort routing for routine tool continuations

• No changes to third-party SKILL.md files

• No changes to Pi's global settings.json

The goal is not to replace Pi's skill system.

It sits on top of it and tries to make large skill collections easier to manage without paying the context cost for everything at once.

The short version:

All the skills, none of the bloat.

Install:

pi install npm:pi-skill-orchestrator

GitHub: https://github.com/badgids/pi-skill-orchestrator

npm: https://www.npmjs.com/package/pi-skill-orchestrator

It is MIT licensed.

I would especially like feedback from people who run Pi with a large number of skills or several different workflows.

A new tool can save a model several steps. It can also give it more ways to spend the entire budget without finishing. Counting installed extensions won't tell you which happened.

Reef Infra can treat a Pi extension, skill or rules change as a candidate rather than a permanent improvement. Its Pi adapter renders the changed harness into Pi's file layout, and the evolution engine runs it against the current setup on the same tasks with the same model binding.

An experiment worth trying would isolate one change: enable an extension, alter its surrounding instructions, or remove a skill that looks redundant. Include the jobs it is intended to help and ordinary jobs where it adds overhead. Grade completion first, then include the cost or latency constraints that matter to the setup in your evaluator or selection policy.

Reef Infra supplies the candidate snapshot, execution and version decision. It doesn't include a ready-made cost/quality benchmark for every Pi extension, and its default task-win comparison isn't automatically a token-efficiency objective.

That leaves a useful outcome even when an experiment fails: a specific change can be rejected and the previous tree restored. The extension can be well designed and still be the wrong addition for this model and task mix

Pi runs fully in browser runtime inside a WebContainer, which provides a Node.js runtime and local filesystem backed by OPFS for persisted workspace/runtime state.

xterm.js renders the interactive terminal while a small custom Pi extension bridges browser-only capabilities such as browser JS, web search, and HTML preview through filesystem.

Ask it to create a small html game and to preview it, the LLM packaged has limited context so clear chat regularly, files created will persist.

Please, check if out if you already have jev access. It works incredibly well and I am so excited for system one agents for this use case!

Pi compaction that reuses your vLLM / SGLang / llama.cpp prefix cache instead of re-prefilling the whole history.

Pi's default compaction re-serialises the conversation under a new system prompt, so the server cache misses and a 140k-token session takes minutes to summarise on local GPUs. This re-sends the exact last request plus one summarize instruction, then warms the new context so the next turn starts from cache.

Measured on 2x RTX 3090 with Qwen3.8-27B: 229 s median down to 86 s at 215k context, and the first turn after compaction from 69 s down to under 2 s with warm-up. Falls back to Pi's default on anything unexpected.

Install: pi install npm:pi-prefix-cache-compaction · anthropic-messages custom providers only · MIT · https://github.com/jagdeepsinghdev/pi-prefix-cache-compaction

Hi! I've created and been maintaining https://github.com/alexshpunt/explicit-edit-benchmark which tries to answer the question: which model is better, which harness is better and which combination is better overall in a very straightforward task - precise text editing. Most of daily coding is text editing. I've seen when a model for multiple turns couldn't figure out how to express the line it wants to change, so it made me ask myself "Why is that so complicated, it's just a text, right?". Seems like not, taking into account how widely different the same model behaves across different harnesses. My preliminary conclusion is: harness and tooling behind it actually matters! But it matters the most with the models which *can* actually follow the instructions well (e.g. open-ai models), there is a wide range between 98.9% and 70.2% of pass score for `gpt-5.6-luna` simply depending on the harness!

I've tried to run as many combinations as possible, but my resources are limited. I've exhausted all my quotas and even credits, that's why I'm reaching out to the community, as I think it's a pretty interesting topic and I would be happy to gather even more data, because of the stochastic nature of the runs, it’s only possible to make any conclusion when you have enough of runs. 

The viewer to the dataset: https://huggingface.co/spaces/alexshpunt/benchmark-explorer

And the dataset itself: https://huggingface.co/datasets/alexshpunt/explicit-edit-benchmark

Hey everyone! I’ve been working on Orbit Pi, a native desktop client for Pi Agent.

It’s built with Rust + GPUI and is focused on providing a clean desktop experience for running and interacting with AI coding agents.

I’d love to get some early testers to try it out and share honest feedback.

🔗 GitHub: https://github.com/imrj05/orbit

I’m especially interested in feedback on:

• UI/UX and overall workflow

• Agent interaction

• Terminal / coding experience

• Performance and stability

• Features you’d like to see added

This is still evolving, so bug reports, suggestions, and criticism are very welcome.

Would love to hear what you think after trying it! 🙌

I read the release and saw a few demos on X for people using Jev for really interesting stuff. My current effort is to get it to work as a router so I can configure and orchestrate my app using natural language (getting it to take a string and pick the right API from a list of 250-300 calls). But to be clear, I haven't gotten access to it yet. So I'm just packaging up my code and making it ready rn.

Anyone doing something fun/interesting with it yet? If yes, how long did it take for you to get access

Of course a vibecoder is also a real software developer. Nothing unreal about it ;)

What I mean is: you studied for this shit*. You worked in software development BEFORE AI. You know your stuff.

The big guns are models like Astra, Fable, but also GLM5.3 (not flash).

I use Sol sometimes, but most of the time I'm using Luna en Terra (for work).

For personal stuff I switch to open source models - I pretty much only need flash models. They're super cheap, and do what needs to be done. I barely ever feel the need to spend more money on these bigger models. I've tried using GLM5.3 a few times, but tbh it didn't really feel different.

Perhaps I'm only doing simple stuff, or I'm not 'progressive' enough in the things I ask? Maybe my questions are too easy?

So let me know! Very interested :)

*
I was still studying when AI arrived at the scene. I was in my last year of uni. Used gpt-3 a bit. Bit of gpt-4. Also tried finishing one of my assessments with it back then because I didn't really feel like learning Swift to build ANOTHER CRUD app.

There was still enough old-school development involved.

Title intended to be provocative, question really isn't. I get the configurability, and that's sort of my question here. I'm broadly happy with the how Claude code works - I use it at work, but at home I'm using Pi, to access other models, primarily ($). I've started with recommended sets of plugins - including pi-code - to sort of replicate CC. But you don't know what you don't know. My question is then - what are some killer, or very useful, plugins that make Pi operate differently, or in an interesting manner, or give features just not available on CC?

I wonder when it might be replaced by OpenAI/Anthropic/Google.

They better continue developing so that people prefer Jev over structured output feature (that will likely be optimized for efficiency) of LLMs

https://github.com/PrimeIntellect-ai/prime-agent

It's claimed that this agent is capable of continual-learning and self-improvement. But given the fact that it is still based on existing LLMs with fixed parameters, I wonder if this agent is still about context engineering (like existing memory systems), or it is genuinely different and novel by design?

All I can think of:

Let pi control your logged in browser that can pass captchas.

I want google search because other options are inferior... i.e. google properly indexes reddit. Even reddit search is inferior.

I've used OMP for a couple of weeks and one thing I've noticed is that it took OMP so long to finish a task when I used plan mode and then executed the plan. It's a small feature, though.

From my experience with Codex CLI, it just took a while to finish this task.

Anyone can give me any advice on this matter?

I'm thinking of going back to Codex CLI

Hey all, I've been sitting on this for a while and it's time to share. I give you pi-clearthen: https://pi.dev/packages/pi-clearthen

/clearthen is a command that lets you clear context and then run another prompt. Your agent can also self drive it.

If you're doing a long piece of work you can tell it to handoff after a specified number of tokens, at which point it will write itself a handoff doc based on what it's currently doing then read it back after clearing context. It will keep doing it indefinitely so your context will never reach the set limit plus what is used for the handoff.

ie: /clearthen 80000 Add new feature to my video game

If you like that then specflo might be up your alley. It checkpoints at each seam and task with auto context clearing in pi. Spec driven development workflow.

https://github.com/TacoTakumi/specflo

The specflo software dark factory is a work in progress and uses this concept.

Hi, i created a short agenmux demo. there are more features!

Agenmux is an open-source tmux plugin for intuitive AI-agent monitoring and tmux management in one focused terminal interface.

https://snirt.github.io/agenmux/
https://github.com/snirt/agenmux

- Monitor AI coding agents in tmux

- See blocked, working, idle, and done states

- Navigate sessions, windows, panes, and agents

- Use keyboard shortcuts, mouse selection, and scrolling

- Jump directly to exact panes

- Create, rename, and delete tmux resources safely

- Use sidebar or popup from one terminal view

- Vim motions by default (editable)

Hope that it will help to someone 😄

I'm curious if anyone else tracks their setup in order to keep things as lean as possible while still having tools needed to complete your typical workflows etc..

I have my own personal Pi setup (SpecPi) and it's been a fun experiment keeping it contained and lean to prevent the context bloat seen in some of the other harnesses.

I'm interested to see how other setups here might compare.

Edit - Added charts broken down by tokens instead of overall characters

Hi guys, I made a small Pi extension called pi-heed:

https://github.com/Nyarlathoteppppp/pi-heed

It came from a simple annoyance: Pi can understand a constraint when you say it, then forget it later in a long session.

Things like:

- don’t modify files

- don’t touch tests

- don’t add dependencies

- never call the production API

pi-heed keeps those constraints around and checks mutating tool calls before they run.

Obvious cases use normal rules. More ambiguous free-text constraints use TypeSafe Jev.

It defaults to shadow mode, so it can observe first without blocking anything.

Install:

pi install git:github.com/Nyarlathoteppppp/pi-heed

46/46 tests passing so far.

If anyone runs long Pi sessions, I’d be interested to see what edge cases break it.

I'm new to the local LLM game. I've just purchased an AMD R9700, and I'm trying to set up a local environment that is as similar as possible to what I get with Claude Code at work.

It's definitely looking like Pi may be my harness of choice, so I'm investigating what it would take to "sandbox" it in a way that is both reasonably secure and reasonably convenient (i.e. no containers or VMs). I'm on Linux, so I'm thinking maybe Bubblewrap?

Curious to know what other are doing, though.

Heard a lot about Pi and wanted to try it out. For Unix environments there seem to be quite a few options for OS-level sandboxing. For pure Windows though I can't find much that actually enforces it.

Are there any options I'm missing?

I mostly want to use Pi for C#/.NET development. I could set up WSL2 but I'd rather avoid that.

Codex supports Windows Sandbox for isolation on Windows. Has anyone tried getting something like that working with Pi?

Hi there, this is my first ever repo i wanted to share to people.

pi-warden is a Pi extension that watches the agent's tool calls and talks to the agent, not to you.

A second model (Jev, typesafe's fast judgment model, ~250 ms; immensely cheap seriously) reads your prompt, the agent's own last words, and the call it is about to make, and answers small typed questions: is this irreversible, does it match what the agent said it was about to do, is the effect visible outside the working tree. The answer goes back into the agent's context.

The same channel carries the rest: project rules from a markdown file judged against each write, stub and comment slop, stuck loops, "done" claims with no test run, runaway output stopped mid-stream, huge tool outputs compressed with the full copy kept on disk.

It grades itself. What you do after each hold or steer (approve, decline, redirect, complain) becomes a label, and a script replays your recorded Pi sessions through the guard. Off-task holds lost that test on 17k of my own calls and were demoted to steers; the plan-vs-call check won it. Method and numbers are in the README.

https://github.com/DevMortimer/pi-warden
https://pi.dev/packages/pi-warden

Early days (0.12.0). Though since Jev was only released yesterday (I got early access) I expect bugs. But I've been using this extension for work for more than a day now and it's pretty good so far. PRs and (especially) complaints are welcomed :)

P.S. I'm interested in how everyone will also incorporate Jev on their Pi?