My Agentic Development Workflow (as of July 2026)

The AI toolset is changing fast, and my workflow is ever evolving like a side character in Lost. I’m starting to snapshot this now so I can look back on it (in maybe 2 weeks at the rate things are evolving?) in terms of how ridiculous it was to think this was optimal. Writing this post, I realized it’s a big ball of thread strung together and a mishmash of various things. This is my personal setup at home below and a testbed for most experiments. I tried living in a single tool but none of them fit every use case.

It’s a stack of tools I’ve noticed most people’s workflows have to do various things and mine is no different. Data movement is to be cautious about and I have local models running on my M4 and thats the direction I sense we are all going after. A factor that can definitely be streamlined is the propensity to test new models as the frontier labs put them out – those posts on LinkedIn stating ‘HeRe’s 5 nEw tHinGs FaBle CAn dO’ trigger FOMO and make you constantly tweak model selections.

Current setup

• Hermes (Nous) is the main coordination layer. Handles daily todos, cron jobs, web research, note-taking in Obsidian, and delegates out to coding agents when needed. Switch out models here via openrouter as required to separate expensive ones from cheaper ones without touching the rest of the stack. I tried Open Claw for a bit but my fingers refused to type ‘openclaw gateway restart’ anymore after every release and the debugging that followed for broken jobs. Hermes is conversational, and it holds state across sessions and just works.
  
• Cursor as the daily driver for anything that lives in a repo. I keep a few contexts open split by job: one for big features, one for debugging, one in agent mode for poking around OSS repos like Pi or Opencode. Background agents run tasks in parallel while I’m off doing something else. It’s wired into my MCP servers (hermes) so it can do more than write code, and I lean on subagents for parallel research and cleanup.
  
  
• Another area I am trying to lean into is local with all the buzz around GLM and Kimi. One setup that’s worked is Cursor pointing at an OpenAI-compatible endpoint served by a Pi.dev harness, which runs Qwen and Gemma on the M4 through llama.cpp. Pi.dev is for the planning and tool calls, Cursor is like the workbench where I edit and read diffs plus I frankly prefer IDEs and not terminal(ly?)-obsessed. It’s way slower than a frontier model, but ok price to pay for sensitive data that never leaves my M4 and the prompt cache stays warm between runs. I still need to research how to run GLM 5.2 locally which will be amazing. But frankly, the idea of working on my mac while it’s wheezing like it needs an inhaler stops being worth it after a point especially when I’m running some heavy processing of audio files and amp modeling software on it for other projects.
  
  
• Claude Code / Codex / OpenCode when I want a raw terminal session instead of the IDE, usually for a one-off script or a quick throwaway task outside a project based on if I have any tokens available. Claude‑Mem is what I am experimenting with currently to ensure a persistent memory layer that can point to multiple providers with the same memory store (especially after all the fracas around models suddenly being withdrawn from consumers). Omnigent is a meta-harness I’m enjoying exploring to migrate some workflows.
  
  
• Obsidian vault as the running brain (influenced by Karpathy): daily todos, TOPICS.md, project notes, and anything I want to persist across sessions.
  
  
• OpenRouter + kimi-k2.7-code as the default model when I’m talking directly to Hermes. I route heavier reasoning to a hosted model and keep the cheap local ones for classification and glue. I’m still figuring out which tasks should touch which models and the rules keep changing.
  
  
• Claude mostly for audio engineering and DAW. For generating mixes that I am not happy with, it’s a great tool that can act as a mixer/ producer and judge the sine curves on your mixes to add compression, reduce gain, increase channel gain etc. I also wrote my own LLM-based tone generator which has reduced tone-tinkering time by 80% in the weekends.

Browser and CLI agents

Two non-IDE modes are Browser agents and CLI that I use.

Browser agents for anything that lives behind a page instead of an API. Playwright MCP handles the research runs, pulling docs, comparing pricing, reading changelogs, scraping a preset library, then dumping the summary back into notes. The rule I’ve landed on is to let it read the web but never let it act on the web unsupervised as advised by all the experts. Clicks that log in and submit forms consume way more tokens than I’ve wanted. I know every security expert rolls their eyes when they see this but it costs too many tokens to do anything truly stupid with a low-risk situation.

CLI agents for the throwaway work – a one-off migration script, a batch rename, a quick log grep. Claude Code, Codex, or OpenCode in a terminal, no project, no ceremony. The whole point is that the task is small enough that I can read the diff in one screen and either keep it or git checkout . and move on.

The split between the two is mostly about how long it takes me to verify this. If I can eyeball the result in seconds, I let the agent run loose and if a wrong step writes to disk or the network or just gets annoying with transient errors, I keep a hand on it.

Evals

For structured-output tasks I keep a small set of cases with a known-good schema and assert against it. Either the output validates and matches the fields I expect, or the run fails via notifications ( and i ignore it). This is usually a Hermes cron that re-runs the set nightly. Since these are personal projects, this suffices.

For the fuzzier stuff, I think I should be using an LLM judge but have not got around to it.

Where this is going

A couple of years ago I was copy-pasting into a chat window or burning through Gemini free API for throw-away side projects (until Gemini choked the free stuff). Now I have a coordination layer, local inference, persistent memory, and evals running nightly with the tooling changing every few weeks.

This may all be a travesty in 6 months but still worth writing down and maybe helps someone choose the tools to use ( or decide exactly what not to use).