My week compiles itself from nine connected channels
I wired every channel I work in into an agent that writes my weekly report from the primary sources. My manager built the consolidation layer above it. Now the two agents are learning to answer each other before either of us gets pinged.
Status reporting is a standing tax
A real chunk of every week went to describing work instead of doing it. I paid in hours; my manager paid in stale snapshots.
- The IC loses hours to non-output work. My week is scattered across Slack, email, Lark, docs, CRM, and ad platforms. Writing the update and keeping a tracker in sync is overhead that competes with the actual work.
- The manager flies on stale, shallow snapshots. Many people, whatever each had time to write, so the real problem surfaces late. Granular detail costs a meeting.
- Every clarification is a human round-trip. Manager asks, I context-switch, dig, reply, they ask the follow-up. One real question can cost two rounds and a day.
Four layers, from my weekly report to a self-evolving loop
Layer 1 turns my week into two records, a status one and a drill-down one. Layer 2 reads both of those across the team and maps the dependencies. Layer 3 lets the agents talk to each other directly. Layer 4 packages the whole thing as skills. I designed it from both seats, the IC's and the manager's: Layer 2 is my manager's build, Layers 1, 3 and 4 are mine, and each one carries its own status.
Nine channels in, two records out
Every surface I actually work in is wired to the agent by whatever connection that surface supports: MCP servers, CLIs, direct APIs, and native integrations. Gmail, Lark, Slack, HubSpot, Google Cloud, Google Ads, Ahrefs, LinkedIn via Zernio, and Apollo all report in. A large share of my real progress lives only inside Claude Code conversations, so the compile also retrieves that week's agent-chat history across sessions and folds it in.
The agent runs this with a configured skill set, and its job description is program manager. It ties the week's raw activity back to the projects already in flight, tracks each one on a sprint rhythm, and watches deliverables and progress per project rather than per message. What it writes out is two records, deliberately. The first is status and progress: where every project stands, what shipped, what slipped. The second drills all the way down into the specifics of each piece of work, and that one accumulates into a personal knowledge base.
Record 1 is what a person scans. Record 2 is what Layers 2 and 3 queryThe manager's agent reads both records, then maps the dependencies
This layer is live, and the build credit is my manager's. Their agent is pointed straight at the two records Layer 1 produces, so it takes every project's status from the first and reaches into the second when it needs the underlying detail. Each IC publishes in whatever channel they choose (a Vercel report, a plain log doc, a Google Sheet), and the agent retrieves from each registered channel and reasons across the whole team. DeepSeek handles bulk summarization; ChatGPT and Claude Code do the reasoning.
Because the team's projects depend on each other, the agent is configured to draw those dependencies as links rather than read each report in isolation. From there it judges on its own whether a dependency is at risk and how each project is actually tracking, and it raises the flag before anyone asks.
I designed the operating model; my manager built this layerThe weekly meeting stopped being a reading of updates
Most of a manager's week goes into collecting status and most of a weekly meeting goes into hearing it recited. The agent has already done both by the time anyone sits down, so the meeting opens on the things a meeting is for: the challenges, where to move resources, what to adjust, and the problems that need a decision. That is the efficiency argument, and it is the smaller of the two.
Transparency matters more. Everyone publishes the same way, every week, at the same depth. A project cannot be quietly behind when its status and its detail both go up. Layer 3 needs this: an agent can only answer for work someone wrote down.
IC and manager publish the same way, every weekAgents notify each other, and answer each other
Once every person's work is transparent and every person's agent holds their own mini knowledge base, the agents can deal with each other directly. When my agent finishes something another project depends on, it pushes that straight to the dependent party's agent as a notification, so the handoff happens without me writing the message. In the other direction, a question about my work goes to my agent first: the asker's agent queries it, or my agent goes and finds the answer in the local sources. Either way the Slack ping never needs to be sent.
The manager's agent uses the same path. When it needs more than the status record holds, it queries my agent, which can answer because it already has the local, granular access from Layer 1. A clarification that used to be a manager-to-IC-to-manager thread resolves in one hop. This one is a pilot, not a running system. I call it the Answer Desk: a SOURCES map over my local channels, a runbook, and a shared Lark channel where a reviewer's agent asks and mine answers.
Two humans see only what the agents could not settleSkills split by role: manager skills, IC skills
As I run this, the repeatable pieces get packaged into skills, and the skills are written per role because the two seats need different functions. The manager set covers consolidating across people, linking dependencies, and judging risk. The IC set covers pulling a week from the channels, keeping the two records, and answering questions against them. The intent is that someone in either seat installs their set and the operating model comes with it. Nobody but me has installed one yet.
The skills then go into a loop so the system can self-evolve. A task I used to do step by step is now done by several agents collaborating, each with its own system prompt, context, and skill. By my own estimate the machinery handles about 85% of that one task, the weekly compile, end to end. It is an estimate; I have not formally measured it.
The engine is my Capstone: reusable multi-agent teams plus a reward-hacking-aware meta-optimizerCalls I made along the way
The agent reads the primary sources directly, so the report carries more granular detail than a person would ever hand-type. Writing status by hand caps honesty at whatever you remember on Friday.
Much of my real progress now happens inside Claude Code conversations and nowhere else. If the compile skipped them, the report would miss the actual work.
Vercel page, log doc, Google Sheet. You register your channel and the manager's agent comes to you. Nobody migrates tools to join the model.
The manager's work is visible to the ICs too. Mutual visibility reads as shared context and trust, and it makes everyone's reporting more honest. One-way visibility would just be surveillance.
The agent checks progress continuously, so standing weekly and daily check-ins get replaced. Humans meet for real problems, strategy, and the calls that need a human review.
Work is captured continuously as retrievable skills, processes, and logs. A departure no longer takes the institutional memory with it.
What's real today
The model is proven where I've run it and piloting where I haven't.
The numbers I don't have
What I'm not claiming: hard before/after time-saved numbers. The lift is real but I haven't formally measured it yet, and I'd rather leave the cell blank than invent a figure. The ~85% in Layer 4 is my own estimate, labeled as one.
What I can say is that the team runs on it. Nobody types a status report into a project tool. Each person keeps their own work on the template, in one place their agent can reach, and reads from it daily. My manager's agent maps dependencies across those records, which is Layer 2 and their build. Mine pulls the same records on a fixed weekly slot and assembles the view I take upward.
Reusability
The channel map, weekly compile, answer-desk, and skill packaging are built as a transferable unit. The model is packaged to be lifted into another org or another IC's setup.
Related work
Claude Code · MCP
Gmail
HubSpot
Google Ads API
Ahrefs
Apollo
DeepSeek
He is an extremely diligent worker whose attention to detail is matched by his understanding of how the details affect the bigger picture.
Keith JamesPayment Solutions Manager
Want the weekly report to compile itself?
The channel map, weekly compile, answer-desk, and skill packaging travel as one unit. Happy to walk through how it would land in your org.