She opened the laptop at the kitchen table after midnight. The schedule the agent had built for Sunday looked clean enough, except the two names were in the wrong places. She knew the story behind the swap. The system did not.
The fields were locked. No drag, no comment, no override. She stared at the blinking cursor, then shut the lid. Someone else would have to fix it in the morning.
The coordinator in this case held the final constraint. She alone knew which names could not appear together. The agent had optimized for coverage and availability, but those metrics never reached the hidden variable of family conflict. The lattice broke where the human authority began.
Products that treat the model as the complete system repeat this break. They optimize inside the training distribution and declare victory when the output looks reasonable on screen. The real work of coordination sits outside that frame, held by the person who signs the schedule and answers for it when something goes wrong.
The first section of any useful lattice must therefore include the person who owns the final yes. Without that node, the model cannot see the actual decision surface it claims to improve.
Munger’s approach forces product teams to keep adding frames until the real constraint appears. In practice this means asking what the coordinator must protect that no training data captures. It also means building the interface so she can act on that protection without leaving the tool.
One team I watched ran the agent output through a second review layer that required the coordinator to confirm or override any assignment. The override rate sat at 18 percent on the first week. Every override logged a constraint the model had missed. Over four weeks the team added three new signals to the prompt and the override rate dropped to 7 percent. The lattice had simply been extended one node further.
The same teams often ask the wrong questions when they run discovery. They ask the coordinator what she likes about the current schedule or how the agent could generate better first drafts. Those questions assume the model already holds the relevant variables. They rarely surface the constraints that live only in the coordinator’s head.
Better questions name the hidden keyholder directly. Ask what rule she applies in the final five minutes before she signs a schedule that no one else sees. Ask which names she has already mentally moved even though the agent has not. Ask what she would tell a new volunteer that the system would never know to record.
These questions turn the coordinator into the additional mental model rather than a reviewer of model output. They expose the permission gate that actually governs the work.
When the product surface exposes those gates, the coordinator can act inside the tool instead of outside it. The next loop then forms around her actual authority rather than around the agent’s next suggestion. The model receives the new constraint as input instead of requiring a separate correction step after the fact.
This changes the retention metric from schedule views to schedule sign-offs that required no external fixes. It also changes the discovery process from periodic user interviews to continuous logging of the constraints the agent still cannot see.
The coordinator who closed the laptop at 9:47 p.m. was not resisting the agent. She simply could not complete her real job inside the product that claimed to help her.
The lattice that stops at the model boundary
The model boundary creates a clean edge that feels complete inside the training data. Outside that edge sit the family conflicts, last-minute illnesses, and unspoken trust relationships that determine whether a schedule actually works. Munger’s lattice requires the product to treat those external facts as first-class nodes rather than exceptions.
Teams that stop at the model boundary measure success by how often the agent produces a usable first draft. They miss the second and third loops where the coordinator must still exercise her real authority. The lattice stays incomplete, so the product keeps optimizing the wrong surface.
Extending the lattice means logging every override as a new signal instead of a user error. It means treating the coordinator’s final yes as the training target rather than an afterthought. The model improves only when the product makes those signals visible and actionable inside the same interface.
Question types that reveal the hidden keyholder
Most discovery sessions ask coordinators to evaluate the agent’s output quality. That framing keeps the model at the center. The better framing asks what constraint the coordinator protects that the model has no way to observe. The difference moves the conversation from preference to authority.
One effective question is to request the last three schedule changes she made after the agent finished its work. Each change points to a variable the model missed. Another is to ask which names she would never assign together even if availability and skills matched perfectly. The answer usually reveals a relationship or history the product has no field for.
These questions treat the coordinator as the additional mental model Munger described. They do not assume the model already contains everything worth knowing. They simply make the missing node visible so the product can decide whether to capture it or route around it.
Designing the next loop around the person who still owns the final yes
The final yes remains with the coordinator because she carries the accountability when the schedule fails. Products that hide the edit surface force her to perform that yes outside the tool. The next loop then starts from a place of correction rather than from the constraint itself.
Interfaces that expose the decision points let her record the constraint at the moment she applies it. The model receives the signal immediately and the schedule improves on the next run. Retention improves because the coordinator finishes her actual job inside the product instead of working around it.
The design choice is simple: every override or manual swap must be one click from the agent’s output. Anything more than that keeps the lattice broken at the model boundary. The coordinator who owns the final yes must be able to act on it without leaving the surface the product provides.
Your Turn: Apply This Today
- Schedule a 30-minute session this week with the actual coordinator who signs the volunteer schedule. Do not show her any agent output first.
- Ask her to list the last three manual changes she made after any automated draft and record the exact reason for each change.
- Ask her to name the one rule she applies that no current field in the system can capture, then write that rule down verbatim.
- Log the three constraints that appeared during the session and map each one to a specific place in the current agent flow where it remains invisible.
- Build a one-screen override panel that lets her record the constraint at the moment she applies it, then feed that signal back into the next model run.
- Measure the number of schedules that require zero external corrections after the panel is live and compare it to the prior four weeks.
The Permission Gate That Kept the Agent From Running the Schedule and The Context Window That Only Closed When a Real Coordinator Sat Down both trace the same pattern of authority that lives outside the model.
I consult with product leaders building agentic scheduling and coordination tools on exposing decision points, logging real constraints, and running discovery with the people who still hold the final yes. Let’s talk.