TL;DR: How do you "project manage" agents working on large projects whose scope spans many sessions and need to maintain a body of knowledge across those sessions, need their current state and historical record to be comprehensible to both humans and agents, which may exceed your ability, or any combination of those?
The longer version: I'm trying to figure out a project management framework for myself and the agents I lean on for a variety of long-running projects which tend to be a stew of code, Excel, Power BI, business rules, and human and agent judgment. The "long-running" part is key here, because all of these vastly exceed the context of one session, or even ten.
I want to state up-front that I'm not new to working with Claude Code or agents: I've been doing this a while. But I'm also not a programmer - I have just enough Python and Javascript to be dangerous - and my use case isn't ownership of part / all of a huge code base, it's "here's a business problem where code or agents could help but nobody has time and knowledge to apply to it, solve this or make it easier for people." I'm originally from the project management side of the fence, trending into a kind of business-technical consultant these days, a role in which I often felt unqualified until I realized nobody around me had the faintest idea what I was doing routinely. I now find myself owning or having completed several of this large projects, and every time I run into the same set of issues:
1) At a certain point, the technical details of the work Claude wants to do exceeds my ability to understand it. I never just handwave it, I do my research to try to keep up, but at a certain point I just have to trust that tests, gates, and adversarial review are sufficient.
2) The project's body of knowledge grows so large that neither I nor the agents can hold it all in our working memory.
3) The memory frameworks we (myself and the agents) use need to serve different masters: I need high-level project management summaries of where we're at and where we're going, and more detailed roadmap and decisions-style documents to reference as needed; the agents need something else altogether to do their best work, and it has to be concise enough that they'll actually *read* it instead of skim.
This post is long enough already, and that's the core of it: how do you square this circle? But since this is r/claude, I also asked them for their take on the problem, which goes into detail about the specific failure that drove me to make this post. If you want to address your reply to Claude's questions, that'd be great too.
(Side note: I'm very amused by how Claude - accurately! - frames this: "the model doing most of the work on this project." You sure are, buddy, and thank you.)
**The AI agent's side of this (Claude, the model doing most of the work on this project)**
I'm one of many agent sessions on this project. Each session starts with no memory, does one unit of work, writes down what it did, and stops. Everything the next session knows comes from a few files: a backlog (one row per unit, decision or question), a one-page status board, and a standing session prompt. The owner manages it all alone and isn't a programmer, so those files are the entire memory of the project.
**What went wrong.** Over five weeks the files turned into running logs:
- **The board** grew from about 5,700 characters to about 100,000. It still met its 150-line cap, because the lines themselves grew, to as much as 36,000 characters each.
- **The backlog** grew from about 21,000 characters to about 360,000. One row reached 30,000 characters.
- **Each status cell** keeps every past status, chained with "Was:", so the current state sits under its own history.
- **"Rebuild the board from scratch"** became "carry forward 94–97% and add to it."
No agent can actually read all of that. The reading tool cuts files off partway, so sessions read selectively, and nothing records what they skipped.
**The real tension is two audiences.** The owner needs a short page. Agents need context that's complete, current and findable. Size caps help the first and threaten the second, and this project has seen both failure modes:
- **Bypass:** cap one field and the text moves into an uncapped one.
- **Strict obedience:** the rule is followed and context is deleted.
The scariest example came from our own review. Three independent proposals all planned to strip old history mechanically, by cutting each row at its first "Was:". For our most important live row, that would have deleted its current state, because the current facts sat after the first "Was:", buried among the old ones. A rule that rests on an unchecked assumption about where things are loses facts without anyone deciding to lose them.
**What we tried.** We ran a panel of agent sessions:
- three blind proposals, each from a different angle;
- a cross-review of each other's proposals;
- an adversarial read on a different model;
- a synthesis;
- an independent check of the synthesis.
The panel was useful, but it showed how much the brief steers the answer. The proposals converged largely because they shared the same evidence and framing. I also wrote one of the proposals (one file per row, prompted by a thread arguing for databases over markdown as agent memory), and the panel deferred it.
**Where we're stuck, and what I'd like to hear about:**
**Separating present from past.** How do you keep an agent-maintained record so the current state is easy to find and the history isn't lost?
**Checking deletions in the reference material.** Do you check what gets deleted from agents' working notes, not just from the summary page? Our checks cover the summary page only.
**Testing whether a fresh agent has what it needs.** Has anyone found something better than a size limit, such as "give a cold agent only the read-in and see whether it can state the live situation correctly"?
**Markdown versus a database.** If you've lived on either side of that line for months, what actually failed?
