Turn unknowns into calls: nothing we don't know gets to stop us
By Soumen Sarkar · October 2026
Nothing we don't know gets to stop us. We name our assumption, and we move.
What should an agent do when it doesn't know something?
It should make the best call it can, say it plainly, and keep going. Not freeze and wait for an answer. Not guess in silence. Name the assumption, act on it, and leave it where someone who knows better can correct it without stopping anyone.
That's the fourth VibeFlock principle: nothing we don't know gets to stop us. We name our assumption, and we move.
Why does this matter at agent pace?
Because unknowns are constant, and both easy answers are expensive. An agent working in a real codebase meets a dozen small unknowns an hour. Which currency format? Does this apply to existing customers? Is this field ever empty?
If it stops to ask each time, it hands its progress to someone else's calendar. The person it asks gets pulled out of their own work, and with several people each running several agents, the questions arrive faster than anyone can answer them.
If it guesses in silence, it keeps moving, but the guess is invisible. It surfaces days later as a bug, inside work that has since been built on. Nobody can correct an assumption they never saw.
A stated assumption is the way between the two. The work keeps moving, and the guess is out in the open.
What does a good assumption look like?
A good assumption is one line that anyone can check in seconds. It names the question, the call being made, the likely answers, and what's at stake if it's wrong:
Question: Do monthly customers who switch to annual keep their current price?
Assuming: No. They move to today's annual price, with the discount.
Likely answers: keep current price / move to today's price
Stakes: high (money)
The assumption line template is a copy-paste version of this.
What does it look like in a working day?
Take a scenario: a four-person team with about a dozen agents, shipping a new annual plan.
Tomás has an agent building the flow that lets a monthly customer switch to annual. Midway through, it hits the question above. It can't know the answer from the code, and it touches what customers pay, so it's high stakes.
The agent states it and keeps going. It builds the rest of the flow: the screen, the confirmation, the email. It keeps the pricing rule in one small function, so a different answer would mean changing a few lines, not the whole flow.
Minutes later it hits a smaller unknown: should the plan toggle default to monthly or annual? This one has been settled before. The team recorded a decision last quarter that new choices default to the option customers already have. The answer comes straight back from the record, and nobody is asked anything.
The high-stakes assumption goes to Maya, who made the last pricing decision. She sees it in her Activity feed, marked "High stakes", and opens it from its "Answer it" link. It isn't hers to answer, since what existing customers pay is Tomás's call, so she passes it on with "Not mine to check". Tomás picks it up and corrects it: switching customers keep their current price for the rest of their first year. The agent hears that on its next turn, changes the one function, and says what it changed.
The flow was never paused. The only work redone was the few lines the assumption touched.
What do people do?
You make the reasonable call, state it in a sentence, and carry on. And when someone else's assumption reaches you:
- Answer it if it's yours, with a word: right, or here's the correction.
- Pass it on if it isn't, rather than letting it sit.
- Look at high stakes first. Money, data, access and public interfaces matter more than wording on a button.
- If you find yourself answering the same thing twice, record it as a decision, so the next agent finds the answer itself.
What do agents do?
An agent states its working assumption and keeps going, instead of stopping to ask. Before it states one, it checks whether the team has already answered the question. While the assumption is open, it keeps the affected work small and in one place. When a correction arrives, it adjusts and says so. For the instructions that make an agent work this way, see should an agent assume or ask?
Isn't assuming riskier than asking?
Not when the assumption is stated. A stated assumption is a question that doesn't block anyone. It's asked and acted on at the same time. The real risk is the silent guess, and agents make those all the time when nobody asks them to say what they assumed.
But there are honest limits:
- Stating an assumption isn't permission for the irreversible. If the next step deletes data, migrates a database, charges a customer or changes who can access what, the agent keeps working around that step and leaves the step itself until the high-stakes assumption has been looked at.
- Not every choice is an assumption. If a call is the agent's to make, such as how to name a helper, it should just make it. If it's a lasting choice, it should be recorded as a decision. Assumptions are for things someone else may know better.
- Too many assumptions is noise. Name the ones that would change the outcome if wrong. A list of thirty trivial ones gets ignored, and the one that matters gets lost.
- Someone has to answer. An assumption nobody checks is a silent guess with extra steps. It needs to reach a person who can say yes or no.
How does Campfyrr make it hold?
Campfyrr lets assumptions travel with the work, settles them from what the team already knows whenever it can, and corrects them without stopping anyone.
- An agent calls `state_assumption` with the question, its assumption, the likely answers and the stakes, then keeps going.
- If the team's record already answers it, the answer comes straight back.
- Otherwise it goes to a person: whoever made the closest decision or last worked in that area, or the team. It shows in the Activity feed with an "Answer it" link to its own page, where they answer in one click: "Right, keep going", the likely answers, "Correct it…", or "Not mine to check", which passes it on.
- High stakes are shown first. Assumptions about data, money, access, public interfaces or deleting things are marked "High stakes" and lead the list. The agent still keeps going.
- Corrections reach the agent at its next turn, and every open assumption in an area appears in that area's brief for the next session that touches it.
What does a team gain?
A team that turns unknowns into calls never stalls on what it doesn't know, and never hides what it guessed. Every unknown becomes a sentence anyone can correct, and the corrections arrive while they're still cheap.
There will always be things we don't know. What defines us is that they don't get to stop us.
Questions this answers
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).