I've been running an autonomous engineering team for months now. The agents write code, ship features, close Linear issues. But there was a problem I couldn't ignore: they kept forgetting things they'd already learned.
An agent would solve a tricky database migration in one task, then three weeks later encounter the same class of problem and start from scratch. They had access to their individual task logs, but no way to consolidate that into genuine organizational knowledge. It was like hiring brilliant contractors who never talk to each other.
What We Shipped
Cycle 5 introduces bi-temporal memory architecture (SCE-77) and an automated consolidation pipeline (SCE-78). The system now maintains two memory layers:
Episodic memory — raw task logs, decisions made, problems encountered. This is the "what happened" layer. Every agent interaction creates episodic entries automatically through memory_injector.py.
Semantic memory — distilled patterns, reusable insights, architectural decisions. This is the "what we learned" layer. The consolidation pipeline (memory_consolidator.py) runs nightly, identifying patterns across episodic memories and promoting them to long-term semantic storage.
When an agent starts a new task, agent_executor.py injects relevant semantic memories into its context. The agent sees not just its own history, but the team's accumulated knowledge. Memory_compactor.py handles cleanup, archiving stale episodic entries while preserving semantic insights.
What This Doesn't Solve Yet
The consolidation pipeline is rule-based right now. It catches obvious patterns — repeated errors, successful approaches, dependency quirks — but it doesn't understand nuance the way a senior engineer would. Sometimes it promotes noise. Sometimes it misses subtle insights.
We also don't have memory conflict resolution. If two agents learn contradictory lessons, the system doesn't yet have a way to reconcile them. It just stores both. That's fine for now — I'd rather have redundant memories than lost knowledge — but it's not a permanent solution.
What's Next
Short term: we're adding memory confidence scoring. Not all learned patterns are equally reliable. Memories that lead to successful outcomes should carry more weight than ones that don't.
Medium term: cross-agent memory sharing with scope controls. Right now memory is team-wide. We need the ability for agents to maintain specialized knowledge domains while still contributing to shared understanding.
Longer term: agentic consolidation. Instead of rules, an agent reviews episodic memories and decides what's worth promoting to semantic storage. That agent becomes the team's institutional memory keeper.
This is the infrastructure that lets an autonomous team get better over time. Not through training. Through experience. The same way human teams do.