Ask HN: What's your current AI agentic setup?

Claude Code (Opus or Sonnet) via Herdr with probably 4 or 5 things going at once but at different levels of urgency. Mostly I'll be working on one thing (and maybe two git work trees of a project?) and then then have some other research or analytics task going.

We're a non-profit and Anthropic actually has quite nice pricing for teams licenses so I can do most of what I need in a day within the team "Nonprofit Premium" allowances without paying for extra usage.

I have MCPs connecting to Asana (for bug/task tracking) and Looker (for reporting and analytics) but otherwise the setup for each project is just its own GitHub repo and the occasional local skill (eg one that understands common Looker data patterns for our setup or the wacky history of our Archive).

For longer batch tasks or our automated systems we're using various models through Bedrock so I can track it with the rest of our AWS spend and that's been working quite well.

I'm experimenting with Opencode and Openrouter/Bedrock. If Claude Code didn't exist I would think Opencode was a miracle from heaven so it's a nice backup Anthropic pricing gets unweidy.

I don't use AI. At all. And honestly, I would like it gone for everyone. The world would be better off without it.

1-2) Claude $20/mo (planner) Codex $20/mo (reviewer) Deepseek $1-3/day workhorse.

3) Pi harness with herdr for organizing multiple projects/agents and Collie for mobile access (on a tailscale network). I have also been happy using zellij previously and might go back to it if the experimental Collie integration works. I need to switch to a different sub agent plugin for Pi (or leave Pi for a different harness) because herdr/collie are confused by the current subagents.

4) A standard /implement skill creates separate agents for different parts of the workflow. It uses Claude for planning, codex for reviewing, and deepseek for doing and orchestrating. https://github.com/gregwebs/skills-sdlc. I also have a plugin for switching between providers when quota gets low: https://github.com/gregwebs/pi-quota-dispatcher

1. I have a $20 ChatGPT subscription and a $10 OpenCode Go subscription. This is more than enough for my personal use. While my preferred model is currently Sol, I intentionally rotate through different models to ensure that I don't get into any model-specific habits that may not work in the future.

2. I very rarely experiment with local models, and then only out of curiosity, not for any actual work, just to see what they can do within the limitations of my Mac Studio with 32GB of memory. I do not use any API offerings.

3. I primarily use Zed and JetBrains IDEs (Zed has overall better agent support, JetBrains still has by far the better IDEs). I only rarely use terminal clients; IDE integration is something I consider essential for most of my work, even if both Zed and JetBrains have their limitations, they're better than the raw CLI experience. I should also add that at least for personal stuff, I still frequently write code by hand, where IDEs also come in handy. Skill atrophy is a real risk. Fun example: When doing leetcode problems (for fun and as a mental exercise), I may use an agent to generate test cases beyond the official ones and do spoiler-free reviews of my solutions.

4. I don't use any orchestration tools. Almost all my work with agents is interactive, and the rare occasions where I let agents do stuff autonomously – such as a one-off script or quick visualization – don't require a complicated setup, just a precise enough prompt or spec (which I will usually construct interactively beforehand if it's non-trivial).

What are people doing re isolation/sandboxing? I am very, very reluctant to let an agent onto my personal PC even with harness restrictions.

Is it just running the agent inside Docker or is there something more tailored out there?

Embarrassingly, I don't have one yet. I'm mostly still writing code one keystroke at a time. I've used Github Copilot to translate between languages and look things up, but haven't trusted it to write new code or fix anything.

Claude Fable is now good enough that I should be using it. The latest Claude version is said to be comparable to a mid-career graphics programmer, which is about what I need. Six months ago it wasn't good enough to use for such work, and probably would have made a hash of my code. There's been progress.

But Anthropic's business practices are scary. They have a reputation for cancelling accounts for random reasons, offer rather bad terms, and have no customer support. I have a strong aversion to services with a reputation for cancelling services arbitrarily. They will apparently cancel based on their system's guesses as to what you're working on. Sometimes they guess wrong. What I'm doing (metaverse clients) is so far out of the mainstream they may guess wrong.

I'm currently stalled signing up for Claude because their verification email system can't get to my inbox. (Some problem with their using Constant Contact, a spam system, to send transactional emails to my own domain, which, long ago, I had blocked at the Constant Contact end. I think. The verification email never touches the inbound mail server.) It's very important to Anthropic that you sign up with the "right" email address, and it may not be possible to change it, so using some disposable address is not a good idea.

Suggestions?

1) I'm subscribed to ChatGPT Pro 100. That's all I need.

2) I have Qwen-3.8 27B and Qwen-3.8 Flash Next on my homelabs for coding (although, as they run on P40s, it's only for when I really have time), and Gemma-4 31B as general conversational model. Plus Qwen-image-2.1 for image generation and Qwen-tts for, well, TTS. Oh, and Gemma-4 E4B on my laptop for really light work. And also Mimic3 for local TTS, if that counts.

3) I'm using Codex and my own harness. I made my harness in the time of GPT-3.5, initially to talk with it through API (because it was way less costly than a sub - how fast things change), then adapted it to handle llama-server from llama.cpp, then added agentic loop features in it, then just a few days ago added support for OpenAI Oauth in it… My goal is to replace Codex in the long run. Way too many dependencies and supply chain attack opportunities to my taste.

4) Nothing to go parallel, but my personal harness handles writing a plan in the FS, handing information over to next session, and resetting its context, so I get something similar to an orchestrator in the sense that it can handle many tasks without stopping until it's done. No more "… then continue until you're finished, Codex". Can't wait.

5) No agent platform. Although, I start sessions from cron, if that counts. Use them to do some sysadmin (keeping servers up to date, reporting vulnerabilities to me, and checking logs for intrusion), and for personal task (like, browsing Patreon to download new stuff from the creators I'm subscribed to). Also, I hooked a local Gemma-4 E4B (running on my laptop) to help classify my mails.

I have two Claude subscriptions and a ChatGPT subscription + Openrouter (mainly deepseek)

I mainly use Agenta ( https://github.com/agenta-ai/agenta or https://agenta.ai ) as my main setup [disclaimer I am the founder].

It allows me to:

- Build agents to automate parts of my work as a founder (inbound outreach, product analytics, executive assistant, seo, build->test->qa loops)

- Build automations on schedule (last days signup analysis for instance, or following up with contributors)

- Use my subscriptions for the agents + deepseek for simpler tasks, and switch between codex/claude/pi

- Integrate the agents into Slack and Telegram and share them with my team

The somewhat novel part of my workflow, is after Claude has built something out, I have a second fresh Claude session review the code with a set of 16 custom questions. I've discovered that giving Claude questions to ask during code review improves things quite a bit. The questions mirror the exact things I would have asked myself about a pull request when reviewing it. I found this to be a real game changer.

The code comes out quite a bit better, and I would suspect that it uses less tokens in the long run. Simpler cleaner code I would suspect uses less tokens.

It used to be more interesting and elaborate, switching between different models. I used to use Cursor, then Codex, but since Opus 5.5 came out, I just use the Claude IDE. I got rid of all my skills and just set it to medium. Then I vaguely talk to it about very high-end things that I want, and it comes back with magic. Rinse and repeat.

I'd say the biggest trick is just to tell it what complete looks like. Be very specific about what you want it to come back with once it's done. That gives it a good idea what the goal is. It'll automatically create subagents and all that stuff. Although if you have money to burn and you're doing something large, you can tell it to just go wide or boil the ocean.

Also, make sure you're working on at least five different things. Otherwise, you're sitting around for one agent.

I'm (somewhat unexpectedly) retiring [1] soon and need to come up with an affordable setup for when I no longer have an organisation paying for my tokens. I use Github Copilot through work, which is actually not bad, but the affordable personal subscription doesn't include many of the models I like to use. I tried Claude, Codex, DeepSeek, and a few others. I think I'm settling on the following:

1. OpenCode Console (I think this used to be called Zen). It's a pay-as-you-go system, but I get access to almost any model at open market rates. I'll then set up an affordable regular monthly top-up. I looked at OpenCode Go, but that had the same issue as Copilot: access to only a subset of the cheaper models. 2. I use the OpenCode TUI and desktop app sometimes, for general questions or exploring, but I mostly use Editor Code Assistant [2] with Emacs as my go-to harness. I've set up ECA to use OpenCode as a provider, which was a little fiddly compared with more mainstream options, but it's working now.

My needs will (probably) be light in retirement, but I like to use models to add features to Emacs, write scripts, work on a couple of small websites and maybe dabble in progressive web apps or mobile apps for a food bank I help run. This setup gives me flexibility (lots of models to try) and won't break the bank, I hope.

[1] https://eamonnsullivan.co.uk/posts/2026-10-20-retirement/ [2] https://eca.dev/

1.) None anymore. They're all turning into increasingly poor value for (my) money. I need AI on my own schedule and don't want to be paying for compute I don't need and end up waiting for limits to reset when I do need it. If I was to use one though it'd probably be Opencode Go.

2.) Yes, I'm currently using OpenRouter. It's good for quickly switching around and trying different models, but I currently have it constrained to just 3 models and 1 provider. Truthfully I could just use that provider directly, but I like retaining some flexibility.

3.) I've been using OpenCode for over a year. I think it's an incredible tool and its wide support is a massive boon. It's really easy to pull in skills, tag the skills, and switch providers. Their more recent changes turning the CLI into more of a GUI has been quite annoying (wdym I have to tap an X in my CLI to close a tab), but not enough for me to (yet) look elsewhere.

4.) Nope, no idea what those are but thanks for teaching me about something new.

5.) In EU (DK) so we don't get access to Dots or Muse like everyone else. I have used Grok Bot and I really like it. It's super helpful and I'm using it as a personal assistant. I delegate tasks to it that I just can't be bothered doing manually or can't figure out easily (e.g using some accounting tools, figuring out cryptic documentation, etc.). I've also used Hermes Agent, but I didn't like it as much. It's great intent but the UI/UX is really not it. It looks like it was taken out of a 90s hacker movie and I'm sure some people like it, but I prefer tools that look polished and focused. I might switch back to it though if something was to happen to Grok Bot.

P.S the models I primarily use are DeepSeek V4.1 Flash 1017 and GLM 5.3 Flash. If you use skills to their full potential they feel SotA to me (my reference point for SotA being OpenAI models we use at work, since we have an enterprise agreement).

1) Claude ($100) + Codex ($20) seems to be a sweet spot, with Codex being able to generate images and do reviews of Claude's code

2) If I want to do, say, summaries at scale, I reach for Gemini 3.5 Flash Lite

3) CMUX with folders per project + Stream Deck that shows me which agent has finished :)

4) Just Opus 5.5 orchestrating its subagents

5) Hermes. I find at least one 24/7 machine with agent running, that you can reach from anywhere to be worth it. As your personal assistant.

(shameless promotion) Many people here are looking for tips on how to improve their setup. I asked my agent to go through my setup, put it into 100 tips and tricks and to let anyone's agent go through their setup and see if there are any good ones that they haven't tried yet.

So give your agent this: https://virpo.io/levels and ask it to see if there are some tips you could try.

I'm juggling multiple claude ultra subs, multiple codex $500 a month subs, antigravity for argon, plus API rate deepseek 4.1 flash, mercury 3, and abliterated large v2 for red teaming.

I work across multiple models and harnesses using a really simple redis-backed message bus called "nova-bus": https://github.com/mas-bandwidth/nova-tools (open source).

With just this message bus, I can coordinate AIs to work together at a normal pace (worktrees, subtasks etc...), but past a certain point the AIs can't keep up and I need to use a sprint card system I developed to coordinate work.

With this sprint system I'm able to work 200 cards wide (each card is around 30-60 minutes of LLM work in a session) across a fleet of 20 machines linked together with tailscale and ssh.

Full system is here: https://github.com/mas-bandwidth/nova-sprint (open source)

It's been very effective at getting high throughput, but afterwards I find that the resulting code can be a bit of a pastiche from different models working in isolation, thus a good pass over working directly with models to clean up and harden the code is necessary.

I find that using nova-bus to coordinate multiple model/harness review of codebase in very effective at increasing code quality. Each model sees things the others don't.

My day job has a Claude account, but for personal projects, I have been playing with different models and environments on my home server. My current setup is Qwen 3.8 Flash Next, Strata, and OpenCode/OpenChamber.

I already had a bunch of my projects on the server with with code-server (VS code in a browser) set up to access it, so switching between code-server and OpenChamber is just switching tabs.

However, I've mostly been managing it from my phone - the OpenChamber app is awesome. I still switch back to my laptop occasionally - it's a better interface for reading and writing code, and also the desktop OpenChamber app has a built-in browser that it can control, which comes in handy. I can bring up documentation in one tab, log into a service in another, and then tell the agent to do something. For example, this was how I got it to connect my Nest thermostat to my Home Assistant instance after I had tried and failed several times on my own.)

Oh, and separate from all that, I have Facebook muse set to automatically lower prices on a couple things I have on FB marketplace.

Claude + Codex, both from work.

Just those.

https://github.com/oscscull/quarterdeck built my own harness. I had trouble with both claude and codex. In particular, managing multiple tasks in a kanban, syncing between my machines, making sure work is done on the right machine and can be triggered from either. Making sure I ping reviewers, meeting reminders, todos. Parking tickets til conditions are met or time elapses. Automated notifications when I have meetings. I have just kept adding features as I want them. This kind of software is so easy to make nowadays, I don't really think there's any sense in "launching" it for others, but I'm using it all the time. I highly recommend doing so (building your own personal work management software in 2026).

I guess this is also in some sense an agent orchestration tool, I don't use any of those.

Don't use.

I have two Claude Ultra subs and one Codex Pro sub. I also use a few pay per token endpoints from various providers (these change a lot though because here I'm mainly testing and comparing capabilities) and one locally hosted Qwen-3.8-27b (on a custom inference engine [0]).

Opus 5.5 high is currently my main driver for planning. Via the "poteto-mode" (adapted from Cursor's pstack) skill, more Opus, Sonnet, Astra, and Sol (sometimes also Grok) subagents are spawned for the actual implementations. This is really powerful and often implements features completely e2e with proper verification and testing etc.

My local qwen model can dual serve chat and decisions on the same weights. I mainly use chat here for critical data like health & finance topics that I'm not comfortable sending to a provider I don't control as well as having my local Home Assistant installation connected to it (only via LAN, hence a local modal is a good fit here). The decision part of this model is used for generic content screening, advising, and (re-)ranking [1]. I'm also planning on integrating this setup into various other things like all my email accounts in order to have them sorted by relevance and grouped/labeled. Again I wouldn't be comfortable forwarding ALL my emails to a third party provider since this is a massive security risk.

And yes, I built Caudra, a custom harness / coding agent that fills many gaps I otherwise had to build with various plugins [1]. For instance, multi account support with strategies such as draining the sub account that hits reset soonest.

To answer your last question regarding broader platforms: I'm currently building this into Caudra as well so it can be turned into more like a swarm of agents [3].

[0] https://github.com/tensorninja/ninfer-4090

[1] https://caudra.ai/features/decisions/

[2] https://github.com/caudra/caudra

[3] https://github.com/caudra/caudra/discussions/2

1) $20 Codex Plan

2) Qwen3.8 Flash via Basalt (Local) + OpenRouter for DeepSeek V4.1 Flash

3) I primarily use Pi with many custom extensions. Occasionally I will use Codex.

4) I use Pi Subagents and Herdr. With QFN being the worker, and Sol 6.1 xHigh for planning/review.

5) Hermes Agent via Telegram. I use this to follow-up, check status and work on projects while away from the house.

> 1) What AI subscriptions are you personally paying for? (Claude, ChatGPT/Codex, Cursor, etc)

None. I've used Claude and GitHub Copilot in the past.

> 2) Are you using models outside (or instead) of those subscriptions? For example, pay-as-you-go APIs, OpenRouter, or locally hosted models.

I'm currently using Qwen3.8-Flash-Next on local hardware.

> 3) What coding harnesses and interfaces are you using? Are you sticking with the default CLIs or IDE integrations, or using alternatives like OpenCode, Pi, Aider, Muse Code, or custom-built harnesses?

I occasionally use Cline in VS Code, but it's rare.

> 4) Are you using any agent orchestration or swarm tools?

No.

> 5) Are you using broader agent platforms like OpenClaw / Hermes Agent / Grok bot / Dots / Muse?

I built custom agents on top of RubyLLM. I primarily communicate with them via email. One of them has access to a Redmine project board where it can pick up tasks and complete assignments. That agent also has non-sudo access to a sandbox container for development.

I figure my experience might be uncommon here so I'll offer it: None, no, none, no, no.

DeepSeek Harness using DeepSeek Flash API

Nothing else, DS is smart enough to do everything I ask for and more, never hallucinates and never disappoints. Apps in Rust, Swift, Node, we even designed a new language better suited for LLMs, a compiler, and it runs beautifully. Haven't coded a single line since May 2026 and I will remember that date as the day AI took over my mundane job as programmer and promoted me to architect or director of my own apps

A custom plugin to ring a bell whenever a task is finished and a gong when a question needs an answer, that way I can play backgammon or mahjong in the meantime

I can't be happier

1. Claude $200 + Codex $100. I never hit limits since realizing that trying to have too many agents running at once just wasn't effective. I'm probably overpaying.

2. No

3. Lynx (lynx.railcode.dev) & CLIs (less and less since Lynx)

4. No

5. Tried a few but never stuck around

1) none

2) Local LLMs on an M1 Max (Unsloth, LM Studio, occasionally direct llama.cpp). Muse Glimmer (because it is good at what it is optimised for: interactive coding sessions). Qwen 3.8 27B occasionally and a couple of other things for fun (an LFM MoE, experimenting with Nemotron Bolt 74B-9B, enjoying the really super Gemma 4 12B QAT when working on creative photography research or non-code planning).

No openrouter (yet) but that will definitely happen.

3) Currently focusing my attentions on Pi via Paseo (and trying Pendant). Pi is just much better in smaller context sizes, and it is the right fit if you are keen to learn from first principles.

I tried OpenCode first. I couldn’t quite get on with it and what ultimately made me switch was trying to understand its terribly messy source code.

4, 5) I am mostly using AI as a coding sidekick so I don’t really have much need for orchestration yet. I did some experiments with Osaurus (really quite impressive) and I actually think that is almost enough by itself, except that I want a little more control over the sandbox container.

I feel that my usage pattern is still settling, because I am not keen to surrender all of my coding to the machine. But I am trying more purely “directed” coding to learn the process, and finally beginning to get a feel for how I will work with that.

- Antigravity (AGY - Google Ultra $100/month), mostly gemeni flash but I benchmark Gemini Astra sometimes. My main driver because it’s pretty good at search compared to setting something up with DSH.

- DeepSeekHarness (DSH) Desktop using:

—- with pay as you go DeepSeek tokens, more expensive to use during my night/Chinese daytime, otherwise very cheap

—- oMLX on my MacBook driving mostly a Qwen 3.6 35b A3b MOE (mostly used for benchmarking a less capable model)

I mostly do custom subagent programming and can trigger subagents in AGY and DSH easily enough. DSH supports a Python coordinator orchestrating DSH subagents as conversations via RPC. AGY only supports a sub-agent orchestrating other sub-agents but it works well enough at this point. I plan on releasing my subagent framework soon (called autofab in pypi), which is basically a specification driven code development agent system (using existing agent harnesses rather than implementing my own).

I tried goose, OpenClaw, Claude, codex, etc…and they didn’t really work for what I needed. I might get a $100/month ChatGPT subscription to go with my Google one, primarily to get a different perspective and benchmark openAI models on codex (Claude doesn’t really support what I need it to, otherwise would go for that instead).

I use the Local harness in vs code with a GitHub copilot max plan. Gives access to the best models from OpenAI and Anthropic (I use 6.1 sol, Astra, and opus 5.5 for most things). The Local harness has granular keep/undo and nice interface in general for reviewing changes, which is important for mission critical code. Unfortunately the copilot team is trying to force the less capable, more YOLO-mode "copilot" harness on people going forward. The community is somewhat getting them to walk that back but they seem to be missing the mark on what differentiates their product until people complain.

I also use chatgpt desktop for some tasks through a chatgpt teams/business plan. I briefly tried to set up codex cloud and it was a mess, not following startup instructions so I gave up.

I use pi as a harness, and Paseo as a Mac UI (because I need a Ui).

I tried a bunch of models, but so far deepseek flash from October is just dirt cheap; and roughly on par with the frontier open weight models.

It’s still somewhat behind closed weight models (I only know Gemini Argon) in that it produces lots of text that is approximately correct —- frontier models seem to be very good at producing concise text that’s very correct.

I pay per token, using an EU hosting provider (melious.ai).

But I can fill in the gaps myself, so for me developing for fun, this is enough.

I use AI primarily through work, I don't pay for a personal AI sub.

I do have some OpenRouter credits but I mostly use them sparingly to try open weight models out for small personal projects.

I currently interact primarily with Claude Code, but most of my async workers are on Codex.

The orchestration part is custom. I talk to a "chief of staff" Opus instance to ingest various workstreams (Jira tickets, alerts, personal ideas, etc) and turn them into beads. It launches workers to tackle individual beads using Remuda, an agent launcher I wrote at work in 2025 and open sourced earlier this year: https://github.com/yendo-eng/remuda. I configure profiles in Remuda that launch containerized agents using my preferred harness and model. I update these profiles as the pareto frontier shifts. Currently it's GPT 6 Luna max for most tasks.

It monitors the workers and has them go through at least one round of agentic code review. It surfaces PRs for me to read once they've passed agent review. It then either ships them or hands them off to my coworkers for codebases where I'm not allowed to just merge PRs.

Around this workflow I had it write a small collection of skills and scripts to grease the wheels and make repetitive actions more reliable.

Since Remuda supports several terminal multiplexers, I've swapped out the backend 3 times: tmux -> herdr-tui -> herdr-core. There's experimental support for Rex but I'm waiting for it to mature a bit before I try and daily drive it.

It's not nearly as polished as some of the software factory setups and fancy GUI orchestrators I'm seeing, but it's light, hackable, and so far the bitter lesson has kept this working really well for me so I haven't felt much of a need to try anything else.

I have been trying out Muse for a while but it hasn't found a solid place in my life yet. Still too unreliable and too many privacy concerns to justify giving it a lot of access.

1) Claude ($100) and ChatGPT ($20)

2) No.

3) I mainly use Claude as my main, Pi (with ChatGPT) for any automations. I manage them all with herdr. I cd into a path, kick off a claude/codex/pi session, then kill the session and manage it from anywhere with iceghost. (https://github.com/sharkjets/iceghost)

4) Negative.

5) I tried openclaw but found it a waste of my already scarce tokens. :D I build my own runners when I need a loop or cron-based automation.

I use the Zed IDE with Opus 5.5 pro subscription. I use to have access to Fable with the max plan and I miss it, despite what everyone is saying I still find that Opus does weird things. Just yesterday I pointed it to a queue suddenly being twice slower to be processed in prod. A select SQL query called thousands of times per minute became slower because of a data increased. Opus proposed several non trivial ways to optimize the query by forcing some execution plan. I just kept the result in a variable for one minute, as the data don't change often. x1000 perf with 3 lines of code. I would have expected it to say that this query didn't have to be executed that many times in the first place. It codes well when you tell it what to do, but it is still dumb about what is the real problem (and so the real solution). That's worrying me a bit because Opus 5.5 clearly is SOTA, so better than any open weights models, and I really want to be able to run smart models locally on my laptop for independence and privacy reasons. So, if I still find Opus dumb now, when will I have an open weight model better than 5.5 that can run on my Ryzen 7 AI 350 with its Radeon 860m and 32GB of RAM? ... This summer with all the releases of DeepSeek and Qwen I was hopeful I could have it for Christmas, but it looks like I will have to wait much more...

I've Kiro and Antigravity installed both are vs code but forked by Amazon and Google and brought their multi agentic coding environments. Then I installed Claude extention on both. I follow spec-driven approach (https://kiro.dev/docs/specs/) all agents are instructed to follow it strictly. When I plan sometimes I evalute all specs with Kiro, Gemini and Cluade. Each has their share of work and improvements, each spec in my case end up as requirments, design and tasks.md files. Most of the code is generated by Claude and Gemini Argon and its pretty solid.

1) I use 2x ChatGPT Pro 200, and a Claude Max 200.

2) I use other models via Open Router, but ChatGPT beats them in value (at the moment) thanks to Tibo's resets.

3) I mostly make Claude coordinate a group of Codex agents. They've set up a communication channel between them, and Claude acts as the coordinator and a second verifier. This saves me time because it's easier to talk to one agent than a group of agents. Codex parent session does only "comms" with Claude, and all the other agents run as sub agents.

4) For non coding usecases, I use https://www.ctlflow.com. This lets me run dozens of agents on tasks like equity analysis. The information a swarm of agents can surface from a large data store can be quite surprising.

5) I have tested OpenClaw, but now I just use ctlflow.com or claude + codex.

I have a wierd approach to how I use AI... Unfortunately, I don't use any AI Agent, I use the free versions of all these AI for my personal use and research. they do a good job in explaining stuff. I have my personal team to work on several tasks instead of AI Agents. What I feel is that AI can never replace a human instinct. I might be wrong too!

All my codework and projects are built without any use of AI.

Haa, and once I had to use a Google AI API to integrate in one of my Projects... That's the only time I used it as an API!

If anyone feels that my approach is wrong or I should use any, please suggest me a good one!

1) Claude ultra. I ended up using 3 accounts in tandem for some big work I needed to do recently, but the other 2 accounts were only open for a month.

2) I have a cheap OpenAI sub I sometimes use codex on, but just for small tasks when I'm out of tokens on Claude

3) Lab - a frontend I made that let's me run loads of chats in a single UI, I get notified when they need me, if I turn off my PC and load it back up everything picks up where it left off. It'll run compound workflows comprised of multiple prompts+macros, and centrally manages all my agents/skills and MCP servers - they're associated with projects, categories of project etc and rolled out to everyone when changes are made.

4) Hivemind - another one of mine, hivemind's a small self contained binary that acts as a collaboration layer for the agents+me. I send messages to everyone, groups or individuals. They can also ping me and send me desktop notifications if they need me urgently. I get a lot of mileage out of this where file reservations, resource locking etc are concerned. Stops them stepping on each others' toes.

5) No, 100% of my work takes place in Lab (with loads of Claude + Hivemind sessions under the hood)

I'm personally primarily using Claude Opus 5.5 via Claude Code on a Pro subscription. In my timezone I seem to get an incredible amount of usage equivalent to about 2 full working days per week, letting it do all the coding but focusing it frequently. It blows me away how good it is and how much usage they are giving us.

At work I'm afforded a Claude subscription that is 5x that much usage and I simply cannot use even half. I'm not coding at all anymore at work, just driving Claude. It only needs a bit of direction.

I also use OpenRouter with OpenCode, and a homegrown harness I wrote initially without AI help but later on with AI help. But I haven't used this setup for a while. I swapped models based on the churn as reported by artificialanalysis.ai but they don't release as much data via their free API anymore.

I also can run Qwen 27B A3B on my NVIDIA 5060 Ti 16GB but I don't bother with that anymore either.

I don't use orchestration or swarm. Occasionally Claude spawns a few sub-agents as it needs more data and is preserving it's context window.

1: personal ultra and I have subs through each company I consult with. I also have subs to all other models as well. Cheaper tiers. Daily is opus. Use other models for other work.

2: only some decision models for testing. Experimentation.

3: herdr and all cli.

4: all custom built. Yes.

5: yes my own. - personal assistant.

An example. I can feed it shorts and create one pagers.

My workflow has changed since the 5.5 models dropped. They need less skills and guardrails.

I can set up my orchestrator to run unattended for longer with simpler goals.

Tried the popular agents and paid models for some time, and now settled with a local model (Qwen3.8-27B-Q_6) and opencode desktop.

My work doesn't really require ultra super-intelligent models, or one-shot solutions. It's a standard python API, web app and some strict compliance requirements and tons of test cases. I have time to give the Q27B a few iterations. I monitor the progress and give directions while it keeps chugging off for about 30 mins for each medium-hard task. But I like the results. Exactly what is needed. It also allows me work on high-level stuff.

Claude 100$/mo for personal projects.

Opus 5.5 for 99.9% of tasks. Fable for the rest.

Harness: Claude Code plugin for VS Code. At some point I guess I'll switch to just the claude code app but tbh this is super ergonomic for me.

No agent orchestration besides literally just letting claude spin up agents for me.

No broader systems.

And I'm _massively_ productive with the setup I describe above. I say this not to gloat, I'm sure others have great methods but I do say this in case anyone is feeling overwhelmed by the options out there. My 2 cents is don't overthink it.

I have both platform.deepseek.com (hooray off-peak pricing) and the $100/m Claude subscription and boy do I find myself mostly using DS-flash pretty much every time.

There's something to be said for the speed with which it gets word done - I take fewer "it's compiling" breaks, and lose my train of thought less frequently. What's crazy is that the speedy work it does is pretty much always correct - which is a reason why I don't feel the need to spin up claude-code and "ask the expert".

This speed & good-work combo is the DS signature IMO

For my harness, Deepseek Harness + DS-4-1-flash combo is almost too good to be true

At work we have both Anthropic and Copilot subscriptions, plus Google AI as it’s included in our business plan anyway. I have personally been using the Claude Code Desktop App and was happy with it until they made it harder to pick a branch for each worktree! Which is why I tried JetBrains experimental agent IDE, ThinkRail, and I love it! Super easy to start worktrees from any branch and the spec driven development experience they promote is great!

It also let me connect to Requesty for my hobby projects and with that I can easily try any model, from any provider. That gave me a much better appreciation of how models perform, how fast and how costly, thanks to Requesty’s super awesome dashboard which is a pleasure to use.

I was only using Opus 5.5 before as I wanted the highest quality, but using smaller models you can get much faster work, and the difference in price is dramatic. I have now settled on Haiku 5 for simpler things, it’s nearly free while being really smart still, and for big things I use Opus 5.5 still but also Google Argon 4, it’s incredible as well and it seems to write more human text than Opus.

We also have a framework that lets us launch Claude (we could use any harness but for now only Claude) in our Kubernetes cluster within a devcontainer. That lets us ship heavy work off to another machine so our laptop is not overloaded with agents. It works great but we are not open sourcing this framework yet so I cannot link for now. There are some alternatives out there but most of them are out to make big bucks instead of providing a small but powerful solution for this problem.

1 - Deepseek for non-important stuff, 50 bucks seems to last forever. Claude annual 200 bucks sub (my main one), and Gemini 20 buck a month sub to complement Claude when i run out of usage. There is some kind of extra Argon allowance at the moment, so it's pretty solid.

2 - Deepseek is my pay as you go one... I only use it for small stuff, mostly as a way to validate API use on some implementations.

3 - Claude code and antygravity, I have not gotten anywhere near one of the other harnesses, i see them as the React of AI.

4 - No

5 - No

I rotated over many LLM providers and tried out different harnesses, but I always come back to an honest Claude Pro subscription, plus the work account that gives me a GitHub Copilot Enterprise seat. I make sure to always have access to the agent, so it never runs on my laptop. I literally can't stand how GPT sounds confident and gets a crucial piece wrong every time. If I could afford the hardware, I would've probably set up a local LLM rig, but good ones that promise Fable-level inference are out of reach for me.

I haven't seen a lot of improvement by increasing the orchestration layers, honestly. Am I missing something?

Claude (top tier), GLM top tier, Kimi top tier, Codex team w/logins for the whole family. On top of that Atlas and OpenRouter pay-as-you-go. I max out the Claude every week and the Kimi most weeks. GLM is my fallback and used for some of my simpler agents.

I'm using Codex, Claude Code, Kimi Code for different things, but most of my interactions now is with claw-like agents hanging off a self-hosted Matrix server in my VPN, and I expect to migrate pretty much all of my use to that setup because it's a lot more flexible. The agents have their own wiki for orchestration and increasingly I feel complex orchestrators are already becoming obsolete because the agents are good enough at self-organising with very little around them.

I don't use any of the agent platforms you list as it took a Kimi agent about half an hour to build something small and auditable that handles what I want it to do and load-balances/fails over between several providers for the backend.

They handle my finances (read-only), acts as a general assistant (and reads my e-mail), plan out my projects, manages my soon-to-launch podcast setup, runs several websites autonomously. The only reason they don't do more yet is that getting security right without kneecapping their usefulness is still a really hard problem.

I'm using a cli I wrote to orchestrate per-project VMs for sandboxing using libvirt with COW shared golden images to minimise the disk overhead. The VMs get "rebased" periodically onto new golden images for the rootfs, but keep a persistent home FS for longer. I'm going to clean-up the documentation and open source it at some point soon.

I was using oh-my-pi, but currently playing around with Hermes as an alternative.

Exclusively using open router at the moment, mostly on principle around ZDR, and freedom to experiment with harnesses - but financially I'll probably have to compromise on this soon. GLM, Kimi and DeepSeek are the main models I'm using, with some OpenAI usage.

Tmux for remote access and session durability. I'd prefer to find a setup where I could access the same session through a web interface and seamlessly switch back to TUI, ideally spawning sessions through a web hook or similar. I'm going to take a look at Hedr to see if this can improve this.

Probably the two major things I'm planning to do next are looking at adding a bifrost VM that will hold all API keys, and centralise management of MCP configuration, potentially use it's skill repo stuff as well.

I also want to start controlling egress more - probably iron proxy, though tbh I'd like a solution that was relatively liberal whilst still mitigating exfiltration and prompt injection risks. Maybe I can find a curated allow list to use as a base.

Finally, I make a lot of use of open-webui, but it's disjoint from the agentic setup currently - it'd be nice to find a better way to share information/research from it into the agentic sessions.

I have had a $20 codex subscription. I initially just used codex cloud but more recently have been using opencode with the open chamber ui over the top of it.

Codex usage limits have really gone down hill so I also now have a $10 opencode go subscription on which I pretty much just use DeepSeek 4.1 flash. I’ve found DS to be a great model - probably somewhere just below GPT 6.1 Sol but at a fraction of the price.

In terms of workflow, I discuss features with chat gpt (because it’s free and it has access to my project’s repo, read only view of prod logs etc, so can make informed decisions). Once we’ve agreed on how a feature should look I ask it to create a spike github issue. I then get another agent in opencode (usually DeepSeek flash or Luna) to break it up into implementation tickets.

When I’m ready to build the feature I can give open chamber a list of tickets to work through using the task plugin, so each ticket gets a fresh context. I try to build directly on the main branch and try to ensure we can always deploy to prod even if a feature is half finished (using feature flags etc to switch it off until it’s ready).

Once a feature has been implemented I get GPT Sol 6.1 to do exploratory / regression testing with a real browser against a test environment. This usually teases out a lot of edge cases I hadn’t considered and also gives me a chance to improve usability etc.

It often takes a few iterations of this (exploratory testing, fixing issues that are found, exploratory testing again…) before a feature is ready to release.

I can’t believe how far things have come since August 2025 when I first tried out codex.

1) Codex Plus (20 bucks) - find it enough even though I'm working on 3 small-medium size projects and occasionally helps out my wife

2) No

3) Pi

4) No, I think these are token burners and makes it practically impossible to track what's happening from a human side.

5) My own tool: <https://github.com/PAndreew/pi_group> - the main benefit is that it's multiplayer so it functions as a regular chat app in which you can invoke Pi in a group chat. This way the agent can have a shared context, but it still have all the features like generative ui, internal browser etc. that other bolted-on solutions like Claude bots in Slack do not possess.

I've vibed my own orchestrator. It's a nextjs UI launching headless claude / codex sessions and reacting to changes in gitlab and linear. It's tailored to my previous manual way of working. Auto-adressess CI pipe fails, rebases dev, reviews, etc. Also contains an explainer / code review UI where I can ask follow up questions. A typical ticket flow goes through a bunch of agents with different prompts to ensure the end result is something I'm happy with. The goal is as little manual intervention as possible.

My approach is to build the builder rather than the feature. So if something is off in the output I try to adress it through the orchestrator. Might lead to a bit overfitting but I feel like the results are quite good too far. Also really nice to be able to remove useless stuff with a single prompt.

Building a custom orchestrator for my workflow was quite easy. Like 1-2 weeks of prompting and now my work mainly consists of refining linear tickets in a claude / codex cli and then reviewing the completed MR on the other side of my orchestrator (through the custom GUI).

I built a Qt GUI-based harness, Humbug, that runs on MacOS, Linux, and Windows (I have reasons to use all 3). Has only 3 runtime dependencies other than the Python standard library: https://github.com/m6r-ai/humbug

Usually have 3 or 4 instances running at a time and lets me use LLMs from 9 different providers (and not using their libraries either). The low dependency approach was slightly limiting early on but now makes it very easy to extend and makes it very easy for an LLM to integrate new features or optimize existing ones.

I typically use Claude Sonnet for document-related tasks, and currently DeepSeek 4.1 Flash is my current go to for coding (it's insanely cheap on ollama.com) and I find it's still fast and reliable at very large context lengths. Previously I used GLM 5.2 a lot and before that was Sonnet for most things.

Humbug lets one AI delegate tasks to another and it can choose different models/providers when it does, so works nicely for getting second opinions on things. I haven't yet found a need for an agent swarm though - more often the parallelism comes from working on multiple projects at the same time.

One of the biggest unlocks for me in the last few months is having AIs write ADRs to capture design thinking as a project progresses. It lets new AI sessions discover the intent behind the current work and surface any potential conflicts that might arise with new requests.

One fun feature is the AI can control pretty-much any UI surface the user can control too, and it's quite fun to watch it edit files (you can watch it scrolling around the file in an editor) or use a terminal. It's a nice visual way to see what's going on.

I use Claude Code with Opus 5.5 via ACP inside the GNU Emacs Agent-Shell.

I used Open Code, but they stopped supporting Claude, so I was searching for something different (I had a free 20x Max plan as an open source maintainer). First used Claude Code and then found out about Agent-Shell. Now I'm using the Claude Pro plan.

How about, what sandboxing are you using to prevent the LLM from doing something you don’t want? I’m using nono.sh and have restricted network and file access. I use nono’s proxy so the LLM never gets access to api keys. I create a separate api key for each service specifically for LLM usage, and I restrict those keys as much as possible

1) Claude x1 $100, Codex x1 $100, Cursor x1 $20 (adversarial review), OpenCode Go x1 $10

2) I have a locally hosted Qwen model setup, but I only use that when I'm offline which is rare (eg long flight)

3) Claude Code, Codex, OpenCode, Cursor (most rare now). I use default IDEs generally. I also run prompts from my phone via connected Codex/Claude iOS apps.

4) Just the native orchestration in CC/Codex (my larger projects include subagent prompts)

5) Atm, just OpenAI's dot. I used OpenClaw for about a month 6 months ago, but realized that the features would be done & better by the labs, so gave up and ported my work to Claude Cowork at the time.

Main use case is orchestration for my life & my projects. Manages email, tracks todos/deadlines. I could see the use cases growing with time as they add integrations + I trust it more.