Before we added Hindsight, our AI project manager had the institutional memory of a goldfish. Every new session, it forgot who was overloaded, who had dropped scope last sprint, every judgment call we'd made. Then we wired in persistent agent memory, and everything changed.
The Real Problem With Stateless Agents
Most developers building AI agents hit the same wall and blame the wrong thing.
The model isn't smart enough. The prompts aren't detailed enough. The context window isn't big enough. So they iterate on all of those — better prompts, longer context, smarter models — and the agent still makes the same mistakes it made last week, because it genuinely has no idea last week happened.
We built an AI Project Manager for a three-person team — Dexter (AI/Backend), Rahul (Frontend), Sohan (Project Coordinator) — handling task assignment, workload balancing, and sprint decisions. The first version was built on Groq's qwen3-32b with a well-crafted system prompt describing each team member's strengths. It worked fine in a single session. The moment we closed the browser and came back the next day, it was a stranger. It didn't know Dexter had just taken on two parallel tasks. It didn't know Rahul had flagged bandwidth issues two days ago. It didn't know we'd already decided frontend and backend work needed to stay separated this sprint.
Every session, we were starting over. The agent wasn't learning — it was just performing.
The fix wasn't a better model or a longer prompt. It was memory.
What We Built
The idea: an AI Project Manager that accumulates institutional knowledge the same way a real PM does — by remembering what happened, what was decided, and what went wrong, and letting that history influence every future decision.
Stack: Streamlit for the UI, Groq's qwen3-32b as the reasoning engine, and Hindsight as the persistent agent memory layer. Every interaction gets retained. Every new query recalls relevant past decisions before the LLM ever sees the question.
![The full AI Group Project Manager interface — sidebar shows team status, sprint stats, and Hindsight memory active]
![ ]
The sidebar shows live team status, sprint stats, and — critically — the Hindsight memory bank status. That green dot at the bottom isn't decorative. When it's on, the agent is a completely different system.
How the Memory Loop Works
Hindsight sits as a layer between user input and LLM inference. The pattern is two calls: recall before the LLM, retain after.
Here's the exact implementation from app.py:
def recall_team_memory(query: str) -> str:
async def _recall():
client = _make_client()
result = client.recall(bank_id=HINDSIGHT_BANK, query=query)
if asyncio.iscoroutine(result):
result = await result
return result
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
result = loop.run_until_complete(_recall())
# parse and return memory strings...
def retain_interaction(user_message: str, ai_response: str) -> None:
record = (
f"Project manager decision — User request: '{user_message}' | "
f"AI recommendation: '{ai_response[:400]}'"
)
async def _retain():
client = _make_client()
result = client.retain(
bank_id=HINDSIGHT_BANK,
content=record,
context="project-manager-decision",
timestamp=timestamp,
)
if asyncio.iscoroutine(result): await result
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(_retain())
The recall query is constructed dynamically from whatever the user just asked:
recall_query = f"team member performance and task history relevant to: {user_message}"
Whatever Hindsight returns gets injected directly into the system prompt before the model reasons about the question:
memory_section = (
f"\n\n## Relevant Team Memory (from Hindsight)\n{memories}"
if memories
else "\n\n## Team Memory\nNo prior context available."
)
What we store as "experiences": the full user request paired with a truncated version of the AI's recommendation, tagged with context="project-manager-decision". We capture the reasoning pattern — not the full response, not raw logs. That distinction matters a lot, which we'll get to.
The full Hindsight documentation covers memory bank structuring and recall tuning if you want to go deeper.
![Sidebar showing team member cards with task status, sprint stats, and the Hindsight memory bank active indicator]
Before / After: Same Question, Different Agent
This is the clearest way to show what changes.
Without memory: We asked — "Who should own the API integration?" The agent said Dexter. Correct instinct. But it had no idea Dexter was already 65% through a model fine-tuning pipeline and had flagged capacity concerns in our session two days prior. It just matched "API integration" to "backend engineer" and called it done.
With Hindsight: Same question, new session three days later. The agent came back with this:
"Dexter should own the API integration. His strengths in ML, APIs, and system design make him the most suitable candidate for this task. He has the technical expertise to ensure robust, scalable, and secure API implementation. Memory Note: Dexter's proficiency in backend systems and APIs was cited in the team's initialization data, reinforcing his suitability for this role."
![The agent citing a Memory Note after assigning the API integration to Dexter — it pulled from past interactions to justify the decision]
The answer was the same — but now it came with justification from memory. The agent wasn't guessing based on a job title. It was citing a pattern it had observed and retained. That Memory Note at the end isn't filler — it's the agent showing its work, and the work is grounded in actual history.
Same model. Same prompt structure. The memory is doing all the delta.
The Moment We Stopped Treating It As a Hackathon Project
About halfway through the build, we asked: "Sohan's sprint retrospective is done — what should they focus on next?"
We expected a generic recommendation. Instead, the agent flagged that sprint planning had historically followed retrospectives in our workflow, and proactively suggested Sohan begin stakeholder prep for the next sprint — before it had been formally assigned as a task.
We hadn't stored "sprint planning follows retrospectives" anywhere. No rule, no template, no explicit instruction. The agent had inferred a workflow sequence from the order of what had been retained over time, and applied it forward.
That was the moment. We'd built a system that was learning process from observation, not instruction. A real PM does exactly that — they watch how a team operates and start anticipating the next move. We hadn't programmed that behavior. It emerged from memory.
The Non-Obvious Lesson: Store Less, Store Better
We expected the hard part to be the open source agent memory integration. It wasn't — the SDK is clean, the recall/retain pattern is intuitive, async support is solid.
The hard part was figuring out what to retain.
First instinct: store everything. Every message, every response, full text, every timestamp. That backfired fast. Recall results got noisy. The agent started surfacing loosely related memories that muddied its reasoning instead of sharpening it. We were effectively polluting our own memory bank.
The fix was two changes: adding a specific context tag ("project-manager-decision") and truncating the retained AI response to 400 characters. We stopped trying to preserve the full reasoning chain and started preserving only the decision pattern. Recall quality improved immediately and significantly.
The lesson we'd carry into the next project: memory quality beats memory quantity, every time. You're not building a log. You're building institutional knowledge — the kind a six-month employee carries in their head, not the kind that lives in a 40,000-line audit trail. Curate it like that from day one.
Try It Yourself
The full project is at github.com/Sohan4-c/hindsight-manager.
You'll need a Groq API key and a Hindsight API key — drop both into .env and run:
streamlit run app.py
The agent starts learning from its first decision. By the tenth, it's a different system than the one you booted up. That's the whole point — and it's the thing no amount of prompt engineering alone will ever give you.
Top comments (0)