Every agent memory setup I've tried has added complexity, but still fallen short. Capturing what happened to the code (kinda๐ซ sorta), but never exactly why.
I don't want a record of what changed. I want the how and why to carry into my next session.
Am I missing something?
Love this, my only question - when the code review agent catches the same mistake for the third time, where does that lesson go?
A factory without memory/learning turns into a very complex way to make the same mistake over and over.
Here's the multi-agent system driving our software factory right now. Core pieces:
- We say what to build (sometimes Linear issues, mostly Slack threads)
- Triage agent researches and decides whether to implement or to ask questions (think /grill-me but smarter)
- Implementation agent builds, maybe collaborating with us on a spec with a subagent first
- Verification subagent tests the implementation agent's work e2e
- Code review agent cycles with the implementation agent for a few rounds before human review
- Human reviews and ships
- Monitoring automation responds to alerts and files issues (our first step to closing the factory loop)
There's room to simplify this. We're benchmarking whether we need separate agents for steps like triage vs. implementation, or if a single high-intelligence model can do most of it. The core loop remains the same though.
Curious how this compares to factories others are deploying
If you've solved something before, especially through working with an agent (no matter which agent), the path to the solution should be kept and easily recalled.
Knowledge should compound. It shouldn't be lost once the task is done.
Anyone else fighting this every session?
wow so i have built like 10 integrations on "GitHub Apps" since it launched in 2018 as an alternative to oauth. I have probably used over 100
none of them was harder to get to the "configure connected repos" than going through chatgpt web to try to connect this to my dot (mind you, this is a page HOSTED ON GITHUB, the provider just needs to link to it)
I've watched an agent burn context rediscovering the same issues I already struggled with last week.
If the last 10 all got lost the same way, the repo is the "bug".
Anyone else get lost in this loop?