I've been experimenting with agentic workflows a lot again in July, especially after the arrival of GPT-5.6 Sol and seeing just how absurdly expensive things can get if you're not careful.
At the beginning of July I wrote about my money-saving Cursor workflow, but that post is already obsolete.
Things have settled down a bit again, so here are my recommendations for mid July.
1. Never have more than three threads at the same time
Ideally, just one. If you're waiting a very long time for something, a second, simpler thread is still fine. Anything above three leads to poor work.
You THINK you're a good multitasker, but you're probably not. You think you're getting more done, while in reality you're exhausting your brain. There is barely any mental energy left for the work that actually requires thinking.
I wrote about this before: you're more productive and less stressed when you don't multitask.
2. Cursor Ultra, Grok 4.5 High Fast, Multitask Mode, delegation, and Beads
Grok as my first point of contact
Grok 4.5 was recently released, and it's fantastic. It's included with Cursor and comes with so many credits that I can barely use them up, so it's now almost always my first point of contact. It's about as fast as Composer Fast but noticeably smarter.
I first use it to help plan what we're going to build. I often have it collaborate with the PI Coding Agent, which is connected to my ChatGPT Plus subscription and lets me use GPT-5.6 Sol Medium at a much lower cost. On top of that, Sol also seems to be significantly more token-efficient inside the PI harness than it is in the official ChatGPT app.
Beads as the collective agent memory
Every task ends up in Beads. It's a task management and memory system designed specifically for AI agents. My favorite feature is that it automatically builds a graph of tasks and their dependencies. Tasks that are blocking other work are completed first, after which all dependent tasks automatically become available for other agents.
Multitasking???
I now use Cursor's Multitask Mode in virtually every thread. Yes, multitasking is bad. But only when you are the one doing the multitasking. It's much less of a problem when an orchestrator agent does it for you.
My strategy is "fire-and-forget". Everything I think of I throw at the thread. I deliberately try not to track what I have already asked to save brain energy.
I also rely on the orchestrator to handle git and resolve conflicts, which is a good brain energy saver as well.
Because everything is delegated to other agents, the root level context window (the context the orchestrator is working with) fills up rather slowly, allowing you to have fairly long conversations. When the context is almost full, you can rely on beads and start a new multitask thread, but in my experience that doesn't happen very often.
Parallel agents fine-tuned to their task
I ask my thread orchestrator to spawn as many parallel agents as possible to complete the task list. At the top level it creates a Grok subagent for each task, which in turn delegates work to whichever agent it believes is best suited.
- Research: usually Grok itself or Composer.
- Small, specialized tasks like i18n: usually a mini model.
- Coding: almost always PI with Sol on my subsidized ChatGPT subscription.
This works great: it's fast and cheap, the output is decent, and I don't spend too much energy on context switching.
Summary
- I now work almost entirely from a single thread. My own multitasking load has been reduced dramatically.
- Grok and Beads make sure no task gets lost or remains blocked unnecessarily.
- Grok tries to maximize parallel execution while choosing the cheapest suitable agent for every task.
- Thanks to Beads, it's easy to give colleagues an up-to-date status overview of ongoing work.
- The combination Grok → PI → GPT-5.6 Sol saves me a huge amount of money because Grok is effectively subsidized inside Cursor, while Sol is relatively inexpensive through my ChatGPT Plus subscription.