The assumption the PM caught at breakfast
By Soumen Sarkar · October 2026
Story. When agents work overnight, let them state their product assumptions and keep going, and let the product manager confirm or correct each one from a link over breakfast. The correction reaches the agent at its next turn, so a wrong call costs a morning, not a sprint.
What happens when an agent makes a product call while everyone sleeps?
This story is a scene, built from how teams work with agents today. What comes after it is real.
It's 7:40 on a Wednesday, and I'm at the kitchen counter of a small office above a bakery. The coffee machine is warming up. Ana, the product manager, isn't in yet. Tom, one of the two engineers, is. He always is.
Tom opens his laptop and goes straight to last night's run. Before he left yesterday, he set a scheduled Claude Code task to build the next item on the plan while the office was dark: letting gym owners pause a member's subscription. The run started at one in the morning and finished a little after three. I lean over his shoulder. The work is good. The pause button is there, the billing stops, the tests pass, and the change is waiting on a branch with its reasons written out.
Then Tom stops scrolling. Halfway through, the agent reached a question the plan didn't answer: what happens when a pause ends? Nobody was awake to ask. So it did what this team asks every session to do. It wrote down its call and kept going: "Assuming a paused subscription restarts by itself after one month."
Tom frowns. It sounds reasonable. It's what he'd have guessed. But he doesn't know, and he knows he doesn't know. Pauses are a product call, and product calls are Ana's.
The team's record already knows that too. The assumption isn't sitting in Tom's terminal. It's on the team's Activity page, waiting for Ana, because she recorded the last decision about billing. Tom clicks the copy-link button next to it and drops the link in the team chat with one line: "Ana, last night's run made a call on pauses. Yours, I think."
At 7:55, a few streets away, Ana is eating toast at her own kitchen table. I'm not there, but she tells me later exactly how it went. Her phone buzzes. She opens the link. The page shows her one sentence: what the agent went with, and that it kept going. Under it, three choices: keep it, correct it, or say it isn't hers to check.
She doesn't have to open a repository. She doesn't have to find the branch or read the code. She knows the answer before she finishes reading the question. Last month, she sat in a call with the gym chain that is their biggest customer. Their members hate surprise charges. The promise they made was simple: nobody restarts without being asked.
She taps "Correct it" and types, between bites: "Don't restart on its own. Email the member a week before the pause ends and let them choose. We promised the gym chain no surprise charges."
It takes her under a minute. She finishes her toast.
At 8:10, Tom sees the page change. The assumption now says "Corrected", with Ana's words under it. He doesn't rewrite anything. He opens the overnight run's session, the same one that did the work, and types two words: "carry on."
I watch the next turn. Before the agent does anything else, Ana's correction is in front of it. It reads the line, says it'll change the restart, and gets to work. It takes out the automatic restart. It adds a reminder email a week before the pause ends, using the email tool the app already has. It adds a choice for the member: restart, or stay paused. It updates the tests and writes down why: "Changed at Ana's correction: no automatic restart, members choose."
By 9:20, when Ana walks in with her coat still on, the change is ready for review. She doesn't ask about it. She doesn't need to. She reads the reasons on the change and nods.
Here's the part I didn't expect. That night, Tom sets the run again, for the next item on the plan: pausing a whole family plan at once. At two in the morning, the new session reaches the same fork. This time it doesn't need to guess. Ana's correction is already in the team's record, against the billing area, and the session is briefed on it before it starts. It builds the reminder email for family plans too, without being told.
On Thursday at 7:40, Tom opens last night's run. There's nothing waiting for Ana. He checks the chat anyway. She's sent one message overnight, about something else entirely: a new idea for the gym chain's next renewal. The team is already a step ahead of her.
Here's what I want you to notice
The agent was brilliant. It built a whole feature overnight, and when it hit a question nobody had answered, it didn't stop and wait for a morning that was six hours away. It made a call, said so out loud, and kept going. That's exactly what we should ask of it.
Look at where the answer was. It wasn't in the code, the plan or Tom's head. It was in a call Ana had with a customer a month ago. The only way that knowledge reaches an agent is if Ana can hand it over, quickly, wherever she is.
And look at how little it cost her. One link, one sentence, under a minute, before work. No meeting, no ticket, no "can you look at the branch when you get in".
Product managers, stop treating the morning as the time you find out what was built. If the agents work overnight, your breakfast is the review. Make it a link you can answer, not a branch you have to read.
The wrong call cost one morning. It didn't cost a sprint, a release or a customer's trust. And because the correction was recorded, the next night's session didn't make the same call again.
What's the proof?
- Agents do work overnight now. Claude Code's scheduled tasks run "on a recurring cadence like hourly, nightly, or weekly" on Anthropic's cloud, "so they keep working when your laptop is closed." The same page says each run opens as a full session, where you can "continue the conversation."
- The answer reaches the agent at its next turn. Claude Code's hooks reference describes the
UserPromptSubmit hook, which fires "when a prompt is submitted, before Claude processes it" and can add context. Campfyrr's hook uses it to tell a session what was answered since its last turn. - We work this way ourselves. The instructions in Campfyrr's own repository tell every session: "Turn unknowns into calls: when something is unclear, `stateassumption` with what you're assuming and keep going. Corrections arrive at a later turn."_ Our own scheduled runs log their work to Campfyrr too.
- Answering from a link is real and shipped. On 19 October we shipped a page of its own for every assumption, so a teammate can open it from a link and confirm, correct or pass it on. The page tells whoever opens it: "Your answer reaches the agent at its next turn, and every later session follows it."
That's what Campfyrr does today. A session calls state_assumption and keeps working. The assumption goes to the person most likely to know, such as the author of the closest decision, and appears on Activity with a link. A correction is recorded, so later sessions in that area are briefed on it. Business teammates, product managers included, join free.
What it doesn't do: it doesn't email or text you the link. Someone shares it, or you open Activity. It doesn't undo work done on the wrong assumption by itself; the agent changes it at its next turn. And the link opens only for people on the team, so a PM needs a free seat.
What do I do on Monday?
- Pick one area where the agents keep making product calls.
- Record your last three calls there as decisions, with your name on them.
- Ask the team to add one line to their agents' instructions: "When something is unclear, state your assumption and keep going."
- Ask whoever starts the overnight runs to send you each product assumption's link in the morning.
- Answer each one from the link before you open anything else.
- Correct in one sentence, and say why in the customer's words.
- Check the next night's run for the same question. It shouldn't come back.
For the product manager's side in full, read for product managers. The problems behind this are stop being the human router and we ship in a day, but feedback takes a week. If a call turns out wrong, what happens when an assumption is wrong? covers the next step, and the playbook for agents that state assumptions has the exact wording.
The problem this answers: The human router: "I'm the human router. Sessions stop to ask, and the questions wait for me."
The principle behind this: Fix forward: We don't guard the gate. We correct the course.
Move as one at agent speed. Nobody waits. Add Campfyrr to Claude: it briefs every agent before it touches the code, keeps assumptions and handoffs where the team can see them, and never takes your code (what it keeps).