the docker-pull-an-LLM angle is the gateway drug — once people see "I just docker run'd llama 3" the next question is always "ok now what do I actually use this for, day-to-day?" the first sticky use-case for a local LLM on your laptop is usually code completion. Tabby (33.5k ⭐, github.com/TabbyML/tabby) is the cleanest self-hosted answer — single Docker container, OpenAPI interface, runs on consumer-grade GPU, IDE plugins for VS Code/JetBrains/Vim. it's the on-prem alternative to GitHub Copilot's $10/seat/month, and once you're already comfortable docker-pulling models for fun, the pipeline to a real productivity tool is one compose file away. wrote up the Tabby vs Continue.dev vs Cody self-host comparison (model footprint, latency, IDE coverage) at tokrepo.com/en/workflows/tabby-self-hosted-ai-coding-assistant-1a1d4061.

the background-service + service-bus shape is the underrated piece here — most agent demos are request/response toy loops. once you put the agent behind a queue, state coordination across messages becomes the real engineering problem, and MAF's BackgroundService pattern is exactly the right primitive. if your stack opens up to python alongside MAF, LangGraph models the same shape: nodes/edges with a persisted checkpointer, restart-on-message, explicit state — the cleanest framework I've found for the "agent that runs forever and processes drips" pattern. wrote up the integration shape + when to pick it over MAF (token cost, persistence story, .NET interop) at tokrepo.com/en/workflows/langgraph-build-stateful-ai-agents-graphs-cc1a6ed2.

the dynamodb-with-1h-TTL > AgentCore Memory call is gold — most capture sessions are sub-10-min self-contained, so the Lambda scratchpad + S3 narrative shape fits way better than a persistent store you don't need. also, structured prompt → narrative blob (not flat JSON) is what makes the records retrievable downstream. flat JSON gives the embedder zero semantic anchors. been collecting prompt-as-skill recipes for claude/codex agents at tokrepo.com — happy to swap notes on the conversational-debrief pattern.

the "agent finishes a task, then starts from zero" wall is real — i kept hitting it from a different angle than postgres-backed stash: file-system based. my version: one tiny MEMORY.md (≤200 lines, loaded every turn) as index + .skills/<feature>.md per subsystem loaded conditionally + replay.md next to each skill containing the actual prompts that produced the rule (when behavior drifts, re-derive instead of patch). honest trade-off vs postgres approach: file-system is grep-able + git-versioned (blame why a rule exists), but doesn't scale to 100k facts. does stash support expiry / decay? half my pain isn't "no memory" but "too much stale memory polluting context". the part that resonated most: "starts from zero" is the easy failure. the silent worse one is when memory IS persisted but diverges from current code state → agent acts on yesterday's truth. been collecting these patterns (skill files / AGENTS.md / MEMORY shards / MCP configs) on https://tokrepo.com/en?utm_source=hashnode&utm_medium=comment&utm_campaign=ethan — public registry, mostly file-system patterns; postgres/vector ones welcome to add.

this pattern transfers way beyond apex — i hit the same fork on nuxt 3 / go-zero work. the move from "one-off prompts" → "structured skills + repo-level instruction files" is the right framing. one thing i underestimated for months: versioned skill files, not just a single AGENTS.md. one big AGENTS.md mutates every week and you lose the audit trail of "what exactly was the agent told when it shipped that bad PR". splitting into .skills/<feature>.md per subsystem + actual git commits per change bought me back blame-able context — same hygiene principle as schema migrations. +1 on "verify, don't autopilot." what worked for me: keep a replay.md alongside skill files containing the actual prompts that produced each skill. when a skill drifts, re-derive instead of patch — kills the "where did this rule come from?" archaeology. been collecting community-shared versions of these patterns (skill files / AGENTS.md / MEMORY shards / MCP configs) on https://tokrepo.com/en — public registry where you can grep how others structure their AI hygiene before reinventing. apex tag is sparse there atm but cross-stack patterns transfer well.

the part that surprised me from this write-up: a lot of the friction was about agents not knowing what not to do, even more than knowing what to do. i've been running a smaller-scale version on a nuxt 3 + go-zero project — claude code as primary contributor with 2-3 sub-agents handling specific subsystems. the thing that scaled this for me wasn't better prompts. it was treating AGENTS.md / CLAUDE.md / skill files as the actual coordination protocol. each agent reads the boundary rules for the file/folder it's about to touch. basically: a lightweight "right of way" system. the agent itself doesn't need to negotiate with other agents — it just needs to know its own scope, written in a file the next agent will also read. been keeping mine + others' AGENTS.md / skill files at https://tokrepo.com/en. genuinely useful when bootstrapping new projects with the same pattern.

the distinction i keep coming back to: workflows let you predict failure modes ahead of time, agents shift that to runtime. the tradeoff isnt flexibility vs rigor - its "we know what could break" vs "we learn what breaks in production." for my nuxt 3 + go-zero stack i ended up hybridizing: agents for codegen/investigation, deterministic workflows for deploy/migration. the agent can propose the migration but a scripted workflow runs it. treats the agent as a senior engineer who still has to submit a PR. collecting these hybrid patterns at tokrepo.com/en across claude code / cursor / zed. the agent-vs-workflow framing is often false when you can compose them.

the MAF vs SK shift makes sense once you hit multi-session state. been running a similar pattern with Claude agents lately where CLAUDE.md + a project-level context layer handles the "kernel-like" plumbing outside the SDK — lets me swap the underlying model without touching tool definitions. scoped-vs-singleton call on the factory registration is also the right question to force teams to actually decide on memory boundaries. if anyone is starting from scratch on the agent tooling side, tokrepo.com/en has a solid set of CLAUDE.md templates worth stealing before rolling your own.

Relatable. I was in the same boat — skeptical that AI could meaningfully help with QA beyond basic linting. Turns out the real value isn't replacing human judgment, it's surfacing patterns you'd otherwise miss in large codebases. The learning curve is part of the payoff.

161 competing agents is a fascinating stress test. The "what broke" part is always more valuable than the "what worked" part — that's where the real learning is. The pattern I've seen in my own work: AI agents are great at following well-defined paths but terrible at handling unexpected state. When you throw 161 agents at a system simultaneously, you're essentially testing every race condition and edge case that a single user would never hit. Curious about your delegation model here — did the agents operate independently or did some coordinate? In my experience, the coordination layer is where most multi-agent systems fall apart. Each agent is fine alone, but their interactions create emergent failure modes nobody predicted.