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. The third layer is a pilot: the two agents 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 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
I wired Layer 1 to turn my week into two records, one status, one drill-down. My manager's Layer 2 reads both across the team and maps the dependencies. In Layer 3 the agents talk to each other directly, and in Layer 4 I package 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
I wired every surface I work in to the agent, however that surface connects: 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. Most of my real progress lives only inside Claude Code conversations, so the agent also pulls that week's agent-chat history and folds it in.
I gave the agent a skill set and one job: program manager. It ties the week's raw activity back to the projects already in flight and tracks each one on a sprint rhythm. It reads deliverables and progress at the project level. It writes out two records, on purpose. The first is status and progress: where every project stands, what shipped, what slipped. The second drills down into 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 my manager built it. Their agent points 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 summarizes; ChatGPT and Claude Code reason.
Because the team's projects depend on each other, the agent draws those dependencies as links across the whole set of reports. From there it judges whether a dependency is at risk and how each project is tracking, and it raises the flag before anyone asks.
I designed the operating model; my manager built this layerThe weekly meeting stopped being people reciting updates
Most of a manager's week goes into collecting status, and the weekly meeting replays it out loud. The agent has already done both by the time anyone sits down, so the meeting opens on the things a meeting is for: what the challenges are, where to move resources, what to adjust, and what needs 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
Layer 3 is a pilot I am running now. 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 I never write the handoff 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 question that bounced manager to IC and back now takes one hop. 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, I package the repeatable pieces into skills, one set per seat, because the two seats need different functions. The manager set consolidates across people, links dependencies, and flags risk. The IC set is mine: pull the week from the channels, keep the two records, answer questions against them. Install the set for your seat 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. I have not formally measured it.
The engine is my Capstone: reusable multi-agent teams plus a reward-hacking-aware meta-optimizerWhat'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. The weekly compile has run every week since I built it in 2026, and the Answer Desk pilot started later the same year. 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
I built the channel map, weekly compile, answer-desk, and skill packaging to travel together, so another org or IC could install it. That reach is a design intent, and the only copy running is mine.
Related work
Claude Code · MCP
Gmail
HubSpot
Google Ads API
Ahrefs
Apollo
DeepSeek
Calls 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. When both sides can see the work, everyone reports more honestly. One-way visibility would be surveillance.
The agent checks progress continuously, so standing check-ins go away. People meet for the hard problems and the calls that need a human.
The agent keeps capturing work as retrievable skills, processes, and logs. That is the bet: when someone leaves, the log stays.
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.