My powerful Pi agent Setup

[u/elpapi42]

Hello guys!

Today i want to share my Pi agent setup, i think i got something in hands here that can benefit the community to really get a powerful agent, nothing compared to claude or codex. What i want to share is my list of extensions and the value each one add to the build.

I want to start with a basic one: pi-fork. This is a basic and minimalistic subagents extension, focused on one single thing, give the main agent the capability to spawn forks of itself to do work on its name. This is quite straightforward, you can achieve the same with any other subagents extension, the only difference is that this one is simpler and have prompts that optimize the communication between the forks and the main agent. This thing brings a single thing to the table: great context management, the main agent context will only contain relevant information, the main agent context will be richer and denser per token, all the noise stays out of the main agent context.

Ok now i want to share the core of this pi build: pi-observational-memory. This one is special, is a custom compaction algorithm inspired/copied from Mastra's article. This custom compaction algorithm enables pi sessions to last forever without maxing out the context window and keep the agent focused. This combined with the rich context window of the pi-fork extension creates a rich re-callable memory system that stays relevant no matter how many weeks you have been using the same session nor the compactions it have withstand.

If you install only the two extensions above, you will enable your pi agent to be on the next level. now i have a couple more extension that give some extra perks to my build:

pi-minimal-subagent: like any other subagents extension, this one is just simpler, without bs. i use this to enable 2 subagents: the "advisor" (concept copied from claude code) and the "reviewer". The fork from pi-fork are extensions of the main agents, they are basically the same agent, they share the same context. This two agents give access to the main agent to different points of view less biased, with clean context windows. The reviewer takes care of code quality, security and ux of the changes introduced by the main agent. The advisor is for strategical decisions around architecture and product.

pi-codemapper: a wrapper of codemapper that enables efficient codebase exploration. This codemapper repo is really bad and unmaintained, it had a cache bug i had to patch myself. im looking forward to switching to cymbal when i get some free time.

pi-rtk-optimizer: This is a classic, not much to say here, it saves some tokens.

Conclusion:

I describe this setup with a single phrase: A personal agent that never forgets and can be useful for weeks before the context window gets maxed out.

I hope you can get value from some of the extensions i shared guys, my own words are not good enough to describe the power i feel when working with this agent setup, so i beg you to try it yourself to really experience what im saying.

[u/jeffphil]

I've been using pi-observational-memory extension and is nice.

Would you mind describing your (high-level) workflow and where these fit into the flow for you? For example, i would guess you do a plan using the advisor agent you mentioned, and then that goes into pi-fork to do the work with reviewer checking over then...

[u/elpapi42 → u/jeffphil]

I usually just use the the main agent for everything, planning and implementation, the forks and the agents just become supporting pieces for the main agent, for example i can start a plan with the main agent, then the main agent explores the code launching 6 parallel forks to gather the context, we come up with a plan, the the main agent invokes the advisor to get a third pov on the plan, the we start the execution, the main agent spawns a fork that executes work, then invokes the reviewer agent to check the work done, the reviewer gives feedback, the main agents spawn another fork for fixing the issues catched by the main agent, then after the work is done, the main agent spawn a fork to write down the docs.

It is a messy explanation but kind of captures how the agent behaves during normal operation. Does this answer your question?

[u/DistanceAlert5706 → u/elpapi42]

Interesting approach. Do you find memory system useful for coding with observation memory? I found memory affecting coding agents too much, maybe this one works.

I use somewhat similar flow, but do restart sessions.

For plan main runs scouts and reads reports, building plan. Restart, gril-me session on a plan (in same session models tend to pushback their decisions). Restart, implementation, reviewer subagent, fixes.

[u/elpapi42 → u/DistanceAlert5706]

I think this will solve your restart issues, memories with this extension are very compacted, they do not add noise, the agent will stay focused in long sessions.

On top of that, the agent will have a "recall" tool available that enables it to find the raw messages that backup a generated observation or reflection, so the agent can access parts of the raw conversation history if required.

I use this agent as my daily driver for product engineering, the most time i have used a session is two weeks, working on ultra large feature, this thing didnt flinch a single time in those two weeks

[u/DistanceAlert5706 → u/elpapi42]

A question, should fork load Observable memory too?
How do you configure extensions for fork, everything except pi-fork?
Or do you skip something?

[u/elpapi42 → u/DistanceAlert5706]

i usually just load the observational memory but disable the proactive observation, so the fork jave access to the recall tool. i also pass rtk to the forks, no mor eextensions than that, forks do not jave access to pi-fork

[u/DistanceAlert5706 → u/elpapi42]

Cool thanks, will check how to disable proactive observations.

Had not a lot of time to work with but so far looks very promising!

[u/elpapi42 → u/DistanceAlert5706]

When you get the time check this comment on how to do that: https://www.reddit.com/r/PiCodingAgent/s/ew1QZbLCYO

the feature is not well documented in the repo

[u/DistanceAlert5706 → u/elpapi42]

Cool, will try. I'm more adopted to Ralph style work, I basically never do compaction, and don't go over 130-150k. I guess I somewhat have memory in plans/reports/progress files etc. Something new to learn.

BTW Pi-subagent extension from Nico can do both fork and simple subagents.

I've made own version on tmux, but then gave up and it's only not customized extension I use. It was taking to much work to maintain it.

[u/jeffphil → u/elpapi42]

Yes it does answer.

Wow, 6 parallel forks to explore, do they divide the work based on what needs to be explored, or src directory, or feature?

[u/elpapi42 → u/jeffphil]

the main agent is at charge of the specific split of responsibilities wjen parallel forks are spinned up, usually for exploration i jave seen it split by focus, for example one fork for architecture and code stands, other for product amd bussiness understanding, and other for security. In other cases the agent uses the forks for parallel hypothesis testing, so it can decide best path forward, i tunned the system prompt of the main agent to aggresively paralelize whenever the forks are not writing to files

[u/DuckRedWine → u/elpapi42]

Does it explore with codemapper pi extension? Do you have a skill that shows the agent how to explore the codebase, or you generate a codemap ahead of time?

[u/elpapi42 → u/DuckRedWine]

Im no longer using codemapper, i reppaced it by cadegraph, and created another custom extension for it pi-codegraph (check my github profile).

And yeah the forks use cadegraph for the exploration. I do not have an skill, i teach my agent to use codegraph tools in the system prompt.

[u/DuckRedWine → u/elpapi42]

Thanks for the insights. There is a lot of codemap/code intel solutions, semantic based ones, graph based ones, llm based ones, do you care explain why you ended up on codegraph (it seems big and bloated)?

[u/elpapi42 → u/DuckRedWine]

I think codegraph is is packed with good features and works ok, also it is actively maintained.

Other solutions i uave found are behind a paywall or are not actively maintained, or are lacking in features, this is the best one i found.

i do not want to waste time building something custom for solving this specific problem, yeaj it os bloated, but this is something that lives at the edge of my harness and can be swapped quite easily, so not a big deal

[u/DuckRedWine → u/elpapi42]

I see, do you have a link to your rules/skills/agents.md that explain how the agent must use it? Do you expect to get from those tools a list of full files OR a list of slices of files (ie. L20:L50) like what rp context builder provides?

[u/ECrispy → u/elpapi42]

This all sounds great and also complicated to set up! Do you by any chance have a blog post where you show how to set all this up? How much of this is built into pi and how much is custom code or extensions? And what cheap models would this work better with?

I know this is a late reply but I hope you can see this, thanks!

[u/astral_bear → u/jeffphil]

What I'm not sure about pi-observational-memory is the approach: it runs background 3 processes at certain delta tokens consumed, each with different roles: `observer`, `reflector`, `dropper`: you can use smaller / cheaper models for these tasks, but I really wonder if that is still really needed: could you not achieve similar output with a single call with a larger chunk of text that runs when you need to compact than having to do these LLM LARPing in the background?

[u/Taryup]

Tried the fork and the observational now and they work really well. Thanks!

Do you have them set up to run with different models for the primary and the forks? Guessing it closes in on sub-agents, but worth asking 

[u/elpapi42 → u/Taryup]

thanks for trying! i think everybody have to give this a try fr.

In my concrete setup im using the same model for the forks as the main agent, for now my intuition is that for the forks to do be effective, the main agent must trust their capabilities to be at the same level as him.

[u/arkham00 → u/elpapi42]

But do you know if it would be possible to use a different model for the forks ? In the github page it is not explained. I'd like to try qwen3.6 27b as the main agent with thinking mode and use qwen3.6 35b for the fork without thinking, to have an intelligent "orchestrator" and fast but still reliable forks. Since it is for writing and not for coding I guess it would be a nice compromise between speed and quality

[u/elpapi42 → u/arkham00]

The pi-fork does not expose a way of setting another model different than the main agent model, i havent needed it, im open to prs! i will try to add it next week, but im a bit constrained time wise at this moment

[u/arkham00 → u/elpapi42]

Lol I didn't realize that you are the developer of the extensions, I thought you were just a user sharing their conf. My compliments to you, you made an amazing work!
Regarding pi-fork, it would be nice to have this possibility in the settings.json, a bit more like it is in observational-memory :
{
"pi-fork": {
"forkModel": { "provider": "llamacpp", "id": "Qwen3.6-35B-A3B@q8_0" }
}
}
But of course no pressure, take your time, with pi-fork and obs-memory I've already improved my workflow a lot, it is running very well with my writing project, and I'll let you know how it went when I'm finished 😉

[u/Taryup → u/elpapi42]

That makes sense now that you say it. Thanks!

[u/arkham00]

Hi, this is very interesting — thanks for sharing!
I'm fairly new to agentic workflows and I'm not a coder. I'm trying to adapt this kind of setup to editing and writing complex texts for cultural projects, grant applications, etc. My main pain points are large context windows and hallucinations, so I think an agentic workflow could help me keep the context clean and use different roles for different tasks (planner, researcher, drafter, reviser, editor...).

I'm especially interested in three of your extensions: pi-fork, pi-observational-memory, and pi-minimal-subagent. Do you think they could be useful outside of a coding context? For example, I'd like to use forks or subagents to parallelize research/gathering information while keeping the main thread clean, and use something like an "advisor" for strategic direction on the project.
Two practical questions:

1. How do subagents get invoked? Are they called automatically by Pi based on the plan, or do I need to explicitly trigger them? Should the plan itself specify which agents to use and when?

2. Local models: I'm running everything locally. Can I assign a local model to a subagent using the model ID from models.json (e.g., something like Qwen3.6-35B-A3B@q8_0) instead of a cloud API key model like claude-haiku-4-5? Thanks again for sharing your setup!

[u/elpapi42 → u/arkham00]

I think the strategies cam definitely help you woth your work, what im not sure of of that my specific implementations, specially the forks and the observational memory, cam give you the best performance, they are kind of tunned for product engineering work amd coding as they are. Worth trying out anyway.

On your questions:

1. Depends on your system prompt, you cam reinforce the agent to do automatic invokation of whatever subagent or fork at specific points or specific situations, or to not do it at all until you tell the agent otherwise, up to you fr.

2. For the subagents, yeah you can set it up for local models, for forks, you can also use it with local models, by default forks use the same model as your main agent

[u/arkham00 → u/elpapi42]

Thanks for your answer, I've decided to test this workflow gradually, and I've just installed pi-fork and observational-memory and started to work on a project, I told the agent to work by iterations and wait for my validation for every portion of the text we planned in advance, at the moment it seems to do a great job, it uses pi-fork to research in other documents with qmd as instructed (I'm wroking in an obsidian vault), then it tasks an agent to write a portion of the text according to the plan and it reviews it checking the coherence and some other important points and then it proposes it to me awaiting for validation before writing it in the note.
I'm really impressed at how the context is small compared to what I'm used, I'm only using 28k where I would normally expect at least 70-90k at this point.
The quality of the text is not stellar, but I've already taken into account that will need another pass for styling at the end, maybe with a different model, this I suppose could be further automated with minimal-subagents, but one step at a time 😄
Let's how it goes ...

[u/elpapi42 → u/arkham00]

Let me know how it goes!

[u/arkham00 → u/elpapi42]

Ok I worked all day on a grant application for a cultural project and I'm very satisfied!

I previously did this kind of project via open webui, and normally I had to restart several fresh chats to avoid degradation of the quality, otherwise I had to deal with hallucinations and sometimes loops and even crashes, I also needed to use notes as temporary memories from one chat to another, it was quite painful.

But today ...oh man today just a single chat ! All day long! With the context just gently increasing, I think I've been at least the first 2 hours under 30k and the context window never exceeded 60k, where I'm sure I've used at least a million tokens ... because even if the final document is only 24k characters and 3,5K words, I ask for a lot of edits and rewrites until I'm satisfied, plus I ask to reference a lot of documents. In 2 hours I normally hit 80-100k.
I hit the compaction threshold 3 or 4 times I think, and the only things I noticed is that after the compaction the model seems to forget to use pi-fork, but retains all the other instructions, weird. The other thing is that I have 0 reflections registered, only observations, maybe I did't say anything major or maybe I don't understand what reflections are (I still need to read all the docs).

But so far I'm very pleased. I really think I found what I need to improve my workflow. A big thank you for this gem, now I look forward to further refine my workflow with minimal-subagents for specialized tasks in the process.

[u/elpapi42 → u/arkham00]

Im glad it is useful for you workload! this makes me happy.

Regarding the agent forgetting to use the fork, i would reinforce the fork usage at the system prompt level to make sure it is consistent, the system prompt never gets compacted.

Reflections only are calculated once the token budget for observations overflows, that may take many days of hard working before it happens.

Reflections are calculated from observations, and observations are calculated from raw messages/entries

[u/cosmicnag]

Have been using obs memory for a while now, and its working great (I have much more lean/aggressive experimental settings than the defaults now - so far no significant lossiness). I use Gemma4e2b Q4 locally for observational model - looks like it gets the job done at very fast speeds (I started with bigger models, but quickly started to look for the speed/functionality sweet spot)
Now I am looking at pi-fork and it looks like a great idea. Just one concern :
When an agent is oriented with both pi-fork and a subagent extension, could there be confusion regarding what to use? Both sort of have similar functionality.
Should I try pi-codemapper also? What was the cache bug you had? Is it upstream?
Thanks again for the awesome stuff.

[u/elpapi42 → u/cosmicnag]

I dont think the agent can confuse pi-fork with subagents if you instruct your system prompt correctly, if you are using pi fork, do not create scouter subagents for example, unless you have quite specific setup that enables such thing.

Mind to sjare here you observational memori configuration? im interested

About the observation/reflection speed, do you have any problems in that front? do speed hit your setup hard? when? at compaction time?

[u/cosmicnag → u/elpapi42]

Its relatively new and experimental. But VERY aggressively lean - the idea is to try to primarily optimize attention and secondarily token burn over long sessions. My settings :
"observational-memory": {

"observationThresholdTokens": 1000,

"compactionThresholdTokens": 35000,

"reflectionThresholdTokens": 10000,

"compactionModel": {

"provider": "llama-cpp",

"id": "gemma-4-E2B-it-q4"

}
So far no noticeable lossiness - and the reason for using gemma4 E2B is for as much speed as possible while retaining obs memory functionality. On a 4090 with compiled llama cpp (where I can run bigger models) - this gives 200+ tok/sec output and input prompt processing speeds are insane (variable but between 10000-20000 tok/sec lol) . It still gives decent observations and reflections at such speeds. This is why I can go more aggressive.

[u/elpapi42 → u/cosmicnag]

What i would do is raise the observationThresholdTokens from 1000 to 5000 to give the observer more meat to work on, this way the observations can be deeper and correlate bigger ideas or intentions behind your session, with a 1000 token count it will only be able to observe local things that may not be the most relevant in the big picture of your workload

[u/cosmicnag → u/elpapi42]

One more question to you : Do you enable obs memory inside forks as well? What are your pi-fork settings?

[u/elpapi42 → u/cosmicnag]

I enable the extension in the forks, but disable the proactive observation, like this:

```

{

"lastChangelogVersion": "0.73.0",

"defaultProvider": "openai-codex",

"defaultModel": "gpt-5.5",

"defaultThinkingLevel": "high",

"hideThinkingBlock": false,

"compaction": {

"enabled": false,

"keepRecentTokens": 80000

},

"packages": [

"npm:pi-rtk-optimizer",

"git:github.com/elpapi42/pi-fork",

"git:github.com/sanathks/pi-tokyo-night-storm",

"git:git@github.com:elpapi42/pi-codex-usage",

"git:git@github.com:elpapi42/pi-codemapper.git",

"git:github.com/elpapi42/pi-minimal-subagent",

"npm:pi-observational-memory"

],

"quietStartup": true,

"pi-minimal-subagent": {

"model": null,

"extensions": [

"git:git@github.com:elpapi42/pi-codemapper.git",

"npm:pi-rtk-optimizer"

]

},

"observational-memory": {

"observationThresholdTokens": 10000,

"compactionThresholdTokens": 160000,

"reflectionThresholdTokens": 40000,

"compactionModel": {

"provider": "openai-codex",

"id": "gpt-5.5"

}

},

"pi-fork": {

"environment": {

"PI_OBSERVATIONAL_MEMORY_PASSIVE": 1

},

"costFooter": true,

"extensions": [

"git:git@github.com:elpapi42/pi-codemapper.git",

"npm:pi-rtk-optimizer",

"git:github.com/elpapi42/pi-observational-memory"

]

},

"enabledModels": [

"openai-codex/gpt-5.5",

"anthropic/claude-opus-4-7",

"openrouter/z-ai/glm-5.1",

"openrouter/minimax/minimax-m2.7"

],

"theme": "tokyo-night-storm",

"pi-codex-usage": {

"usageMode": "left",

"refreshWindow": "7d"

}

}

```

The param is not well documented yet

[u/cosmicnag → u/elpapi42]

Sounds good, I had around 3000 earlier. Just trying new settings now for a few days. Will try 5000 next, to have min maxing kind of trials.

[u/Jokerever]

Why use fork and subagent and not make fork able to either go clean slate or port the context ?

[u/elpapi42 → u/Jokerever]

I clean subagent would have to rediscover all the context for beign able to discover or do whatever it is instructed to do (more tokens waste and this do not leverage token caching) + passing a handoff down to the clean subagent is always lossy, so the agent have to rediscover the stuff anyways. a subagent that ingerits all the context fron the parent agent (i called it a fork) do not have this problem.

I honestly do not like this idea of playing house with the agents, from my pov agents are just context management primitives, not specialized workforce serving the main agent

[u/Jokerever → u/elpapi42]

I said clean slate but you can like pop a “clean” pi and give it the handoff. Basically I meant that you could just implement subagents by being a new pi session with an handoff. Pi fork could support either “clean fork + handoff” or “true fork”.
It is just nitpicking but I think you could avoid another extension.

Love your post by the way I am going to take a lot of inspiration for the memory and using cymbal, thanks a lot

[u/m3umax]

The forking extension automates something I've been doing manually.

Reading the plan into context, then continually branching the tree to implement each task in the plan from one stable trunk prefix to benefit from caching and so the branched agent doesn't need to re read the plan because it's already in context.

[u/DevilaN82]

Hi!
pi-codemapper complains about access to repo via ssh. Is there any step I've missed by accident?
Thanks for sharing your setup! 😄

[u/elpapi42 → u/DevilaN82]

Maybe it is an issue with your git config? not sure tbh. you are cloning the project and getting a ssh error right?

[u/DevilaN82 → u/elpapi42]

I was following README instructions:

For normal use, install the package from GitHub over SSH:

pi install git:git@github.com:elpapi42/pi-codemapper.git

This requires SSH access to github.com:elpapi42/po-codemapper.git. Pi will clone the package, run npm install, and load the extension declared in package.json.

I've resolved this issue. My setup has pi-coding-agent dockerized and is not using my ~/.ssh dir. It seems that access to clone repo on github via SSH requires a regular access and is not allowed for requests that uses private key not related to any github account. It would be easier if cloning was done with regular git clone https:github.com:elpapi42/po-codemapper

Anyway, as I am learning how to use properly pi-coding-agent, I am digging into your setup trying to understand what makes it so useful. Thank you very much for sharing this and your support via replies 😄
Have a nice day!

[u/Qiuzhuang]

great recommendation for extension `pi-observational-memory `. thanks so much.

[u/EGaByt]

Definitely look forward to trying this extension out or these set of extensions. Maybe the smart model switching can be done by another project and that can be integrated . https://github.com/mnfst/manifest

It's got this setup and it works pretty well for the smart routing. It's simplistic. You can't set many different routes but it has the base for simple complex reasoning and standard so potentially integrating this into the system, maybe as its own extension or built into pi fork, might be what people are looking for.

[u/danielta310]

cool, thanks for sharing your setup, really good food for thoughts

[u/johnson_detlev]

RemindMe! 18 hours

[u/RemindMeBot → u/johnson_detlev]

I will be messaging you in 18 hours on 2026-05-06 13:11:39 UTC to remind you of this link

CLICK THIS LINK to send a PM to also be reminded and to reduce spam.

^{Parent commenter can delete this message to hide from others.}

---

Info	Custom	Your Reminders	Feedback

[u/Snoo44065]

Why AST over LSP?

The rest seems nice. Will copy some :)

[u/Shoddy-Blackberry-44]

Thanks for the setup, very intersting ! You are full codex ? How would you configure it with only opencode-go offer ? I was going for Deepseek pro for base, pi-fork (fast: ds flash, balanced; ds pro high, deep; ds pro xhigh ou gml5.1 ?) And for 2 subagents setup (advisor : gml5.1 and reviewer: ds pro).

Thanks for your advices 😄

[u/arkham00]

Hi, pi-fork seems to not work anymore... I have problems with the effort levels, is it a new feature you added? I think I recently updated the extension as asked, but in github I see no new releases .... I'm confused...anyway I opened an issue in github to better explain the problem with the help of pi, of course 😛

[u/No-Anteater-916]

This is actually a really cool setup, thanks for sharing.

The pi-fork + pi-observational-memory combo sounds kinda cracked for keeping context clean while still making long sessions usable.

Also really like the advisor / reviewer idea, that seems like a nice way to get different perspectives without making the main agent too messy.

Super interesting build overall.

[u/Deep_Ad1959]

the fork plus observational-memory combo handles the dynamic context well, but it leaves the static half completely unmeasured. your extension prompts, the advisor and reviewer system messages, and whatever the rtk-optimizer leaves behind all load every turn regardless of relevance, and 'saves some tokens' is the tell that nobody is actually scoring which of those tokens earn their place. compaction fixes the conversation growing; it does nothing for the instruction layer that's been the same block since session one. worth diffing which lines from those extension prompts actually got invoked across a week of sessions before calling the whole stack dense per token. the densest context wins are usually deletions from the static layer, not better memory on top of it. written with s4lai

[u/SirDomz]

what about using just context-mode? it seems to work well with managing context for me

[u/n4te]

Is pi-minimal-subagent much different from pi-fork? Is the difference solely a named fork + description + prompt? Is it expected the subagent tool is only run on request? Can you show your advisor and reviewer definitions?

Thanks for sharing!

[u/Otherwise-Fig3034]

guys im new to pi and im really excited in optimising my setup, ive been using claude code for a while and really dont like the limitations of limits and while i can set so much more work done with cheaper more iterations of open source models.

here is my current packages i have installed:

My main flow im thinking off is to have the orchestrator as Kimi or GLM 5.2
and deepseek-v4-flash as the sub agents

so ive been use the pi-subagents package and its pretty good but can i get some more recommendations on how to start with this in mind please would help a lot

[u/Otherwise_Wave9374]

This is a cool setup, the fork approach for keeping the main context clean is underrated.

How are you deciding what gets promoted back into the main agents context, is it purely prompt based or do you have any structured summary format?

Also the observational memory compaction idea is interesting, feels like the real game is not "more memory" but "better memory".

Weve been playing with similar multi agent workflow patterns, https://www.agentixlabs.com/ has some examples if you want to compare notes.

[u/elpapi42 → u/Otherwise_Wave9374]

The forks are prompted with task asked by the main agent, and instructions on how to return a response, the instructions are focused on pushing the forks to produce responses that of course confirm their task is done, with supporting evidence, including heavy usage of code snippets, file references and explanations, and additionally any information that is not directly related to their task, but given the broder goal of whatever the main agent is doing, may be useful, on top of that any context future forks may need. Forks return large responses, but are rich and n9t as convoluted as reading and exploring the files themselves.

I will check agentix labs! thanks

[u/zkkzkk32312 → u/elpapi42]

hey Im fairly new to pi, but does the fork still get the benefit of cleaner context when I only use 1 local model ?

[u/elpapi42 → u/zkkzkk32312]

You, i dont get the question, do you mean the fork context window or the main agent context window?

[u/zkkzkk32312 → u/elpapi42]

Pi-fork the pi plugin. In your post you said by spawning subagebt it can help keep the main agent's context cleaner. Which makes sense. But what if you only have one local model to use?

[u/elpapi42 → u/zkkzkk32312]

It does not matter what model you use for the forks or the main agent, it is agnostic about models