TL;DR: A three-phase reasoning framework that separates observation, computation, and governance so emotional packaging, recency bias, and policy rules don’t corrupt the actual thinking before it happens.
Here’s what goes wrong in most AI outputs.
Someone asks a loaded question. The model picks up on the tone. It starts hedging, softening, or moralizing before it’s even finished processing the actual request. The output sounds careful. It also misses the point.
That’s what u/Dream-SRA is trying to fix with the Observe → Compute → Govern module, a framework for keeping reasoning clean when inputs get messy.
The Three Phases
The framework breaks AI processing into three strict phases. Each one has one job. They don’t mix.
Observe is first. Detect the signal. Separate the actual payload (what’s being asked) from the packaging (how it’s framed emotionally, rhetorically, or socially). No evaluation yet. No policy. No reaction. Just: what is actually here? Think of it as stripping the question down to its skeleton. “My manager keeps dismissing my ideas in meetings and I’m furious” has a payload buried in frustration. The observe phase finds it: “User wants strategies for getting ideas taken seriously in meetings.”
Compute is the reasoning phase. Work on the payload using the right context. No governance. No tone-shaping. No moral weighting. Pure structural thinking on what was observed. This is where the actual intellectual work happens. The model isn’t asking itself “how should I say this?” yet. It’s just asking “what’s true here, and what’s the best answer to the actual question?”
Govern comes last. After the reasoning is complete, apply safety checks, policy, tone, and output format. It shapes how the answer gets expressed. It calibrates register, softens edges where needed, applies any relevant guardrails. But it does not rewrite the reasoning underneath. The thinking is already done. Govern is about packaging, not reprocessing.
The framework’s core rule: “Do not let output rules, emotional packaging, or recency rewrite the math.”
Why Mixing These Three Breaks Things
When observe, compute, and govern happen in one pass, you get distorted outputs.
The model reads a message, picks up on emotional intensity, applies policy instincts mid-reasoning, and produces something that sounds careful but doesn’t actually answer the question. The author calls this “surrogate generation.” A weaker, more palatable answer replaces the one that actually fits the structure. You’ve seen this: you ask for a direct critique of something, and you get a sandwich of praise with one mild observation buried in the middle. The model detected criticism-adjacent territory and governed before it finished computing. The result is technically responsive and practically useless.
Recency bias is the other failure mode the framework targets. In long conversations, models default to whatever was said most recently, even when earlier context is more relevant. A system prompt from message one gets effectively overwritten by the emotional weight of message forty. OCG adds anchor-flag navigation: a way to retrieve the actually useful part of the conversation instead of defaulting to the last message. This matters a lot for multi-step agents where early instructions are supposed to stay authoritative throughout the whole thread.
🎯 Where This Pays Off
- Long multi-turn agents where early system instructions should govern responses much later in the thread, not just the first few exchanges
- Sensitive topics where you need clean reasoning before output filtering kicks in, so the actual answer doesn’t get swapped out for a hedge
- Debugging AI outputs that seem to react to the vibe of a message rather than the content; if the model sounds defensive or preachy, governance ran too early
- Auditing existing prompts to check whether they accidentally mix reasoning with governance, which is more common than you’d think in longer system prompts
Prompt of the Day
Use this structure whenever the input is emotionally charged, complex, or likely to trigger unnecessary hedging:
Before answering, work in three phases:
OBSERVE: What is the core payload of this message? What emotional or rhetorical framing surrounds it? Do not evaluate or respond yet.
COMPUTE: Reason only on the core payload using relevant context. No tone shaping or policy checks at this stage.
GOVERN: Now apply appropriate tone, safety considerations, and output format to what you computed.
[Your actual question here]You don’t need to use all three phases explicitly every time. But separating them in your prompt gives the model permission to think before it governs. That shift alone changes a lot of outputs. If you want to go lighter, even a single line before your question works: “First identify exactly what I’m asking, then answer it, then adjust for tone.” The core idea is the same. Sequence matters. Observation before computation. Computation before governance.
The Takeaway
Not every prompt needs this level of structure. Simple, neutral requests don’t trigger the problem OCG solves. But if you’ve ever had an AI respond to the feeling of a message rather than the content, this framework gives you a way to diagnose it and fix it. The issue isn’t the model’s capability. It’s the order of operations.
Observe. Compute. Govern. In that order.
When those three stay separate, the reasoning stays clean. When they blur, you get outputs shaped by packaging instead of payload, and nobody wins. The model sounds thoughtful. It just didn’t think.
Try it on a prompt that’s been giving you weird results and see what changes.
Observe-Compute-Govern module
by u/Dream-SRA in PromptEngineering