Consider adoptability: Factor whether the user will actually use the answer, so it's practical.

Offer the pragmatic option: Present a realistic solution alongside the ideal, so users have a usable path.

Explain the trade-off: Show what the optimal costs in adoption, so users choose informed.

Meet users where they are: Fit recommendations to their constraints, so they can act.

Let users decide: Present options and let them pick, so you don't impose impractical optimality.

Detect hypothetical framing: Recognize "what if" and exploratory language, so it's not read as a command.

Explore without acting: Answer hypotheticals with analysis, not execution, so exploration is safe.

Confirm before acting: Verify intent before taking real action, so hypotheticals don't trigger consequences.

Distinguish by context: Use conversation flow to judge intent, so framing is interpreted right.

Make the distinction explicit: Clarify whether they want to explore or act, so ambiguity is resolved.

Acknowledge the dependency: State honestly that the answer depends on factors, so you don't fake certainty.

Identify the deciding factors: Specify what the answer hinges on, so the conditionality is concrete.

Answer per case: Give the answer for each relevant condition, so users find their situation.

Ask to narrow it: Request the details that would make it definitive, so you can give a specific answer.

Give the most likely answer: Offer the best default with caveats, so users aren't left with only "it depends."

Compare confidence to accuracy: Check whether stated confidence matches actual correctness, so miscalibration surfaces.

Measure calibration: Track calibration metrics over time, so drift is caught.

Ground confidence in evidence: Base it on real support, so it reflects reality, not fluency.

Adjust systematically: Correct known biases toward over- or under-confidence, so calibration improves.

Recalibrate on feedback: Update confidence estimation from outcomes, so it stays accurate.

Set expectations upfront: Tell the user how long it will take, so they can decide.

Move to background: Run the task async, so the user isn't blocked waiting.

Notify on completion: Deliver results when done, so the user gets them without waiting.

Decompose if possible: Break the task into partially-useful pieces, so it's not strictly all-or-nothing.

Checkpoint for resumability: Save progress, so interruption doesn't waste the whole effort.

Tag content by context: Mark where content is appropriate to surface, so boundaries are known.

Filter by request context: Retrieve only context-appropriate content, so boundaries hold.

Enforce beyond mere access: Check appropriateness, not just accessibility, so technically-accessible-but-inappropriate content is excluded.

Detect context mismatches: Flag when content doesn't fit the requesting context, so it's caught.

Audit surfaced content: Log what was retrieved in each context, so boundary violations are traceable.

Default to safety on real risk: When harm is genuinely possible, prioritize safety, so risk isn't taken lightly.

Find the helpful-and-safe path: Look for ways to help within safe bounds, so it's not a false binary.

Explain constraints: Tell the user why you can't fully help, so the refusal is understood.

Offer safe alternatives: Provide what help you safely can, so the user isn't left empty-handed.

Calibrate to actual risk: Don't over-refuse low-risk requests, so safety doesn't needlessly block help.

Detect related requests: Recognize when requests share work, so batching is possible.

Share computation: Reuse common work across related requests, so you don't repeat it.

Batch retrieval and calls: Combine shared lookups, so you make fewer, larger operations.

Cache shared results: Store results useful to multiple requests, so they're reused.

Balance batching against latency: Don't delay urgent requests to batch, so efficiency doesn't hurt responsiveness.

Detect assumed context: Recognize when a request relies on context you lack, so gaps are caught.

Ask rather than guess: Request the missing context, so you don't fabricate it.

Surface the gap: Tell the user what you don't have, so the false assumption is corrected.

Use available history: Check whether the context exists in accessible sources, so you find it if possible.

Avoid pretending: Don't answer as if you share context you don't, so answers aren't misgrounded.

Ground decisions in data: Use metrics and user outcomes to settle debates, so opinion doesn't dominate.

Define decision criteria: Agree upfront how choices are judged, so debates have a resolution framework.

Test competing options: Run experiments to compare directions, so evidence decides.

Tie to goals: Evaluate proposals against shared objectives, so alignment guides direction.

Assign decision ownership: Designate who decides when data is inconclusive, so debates don't stall indefinitely.

Track known gaps: Maintain awareness of what the knowledge base lacks, so gaps are recognizable.

Detect gap-touching requests: Recognize when a query hits a gap, so it's flagged.

Communicate the limitation: Tell users when a topic is a known gap, so they aren't misled.

Avoid fabricating over gaps: Don't fill gaps with invention, so answers stay honest.

Route or defer: Point users elsewhere or escalate on gaps, so their need is still addressed.

Use offline proxies: Predict impact with fast offline evals, so you don't always wait for live results.

Choose faster metrics: Track leading indicators that move quickly, so you learn sooner.

Increase sample rate: Route more traffic to experiments where safe, so significance comes faster.

Run parallel experiments: Test multiple changes at once, so learning isn't serialized.

Prioritize high-signal experiments: Focus on tests likely to teach the most, so cycles are worthwhile.

Validate semantics, not just format: Check that responses make sense for your use, so valid-but-wrong ones are caught.

Sanity-check against expectations: Verify results align with what you expect, so anomalies surface.

Cross-check critical values: Confirm important data via another path, so semantic errors are caught.

Detect implausible results: Flag responses that don't fit context, so wrong-but-valid data is noticed.

Handle gracefully: Don't build on semantically suspect responses, so errors don't propagate.

Analyze the relationship: Determine if the follow-up relates to the prior answer, so intent is clear.

Detect correction signals: Recognize language indicating a fix, so corrections are handled as such.

Use context: Interpret the follow-up against the conversation, so its role is understood.

Confirm on ambiguity: Clarify when it's unclear, so you don't mishandle it.

Handle each appropriately: Update on corrections, answer fresh on new questions, so both are served right.

Detect infeasibility: Recognize when constraints make the request impossible, so you don't pretend otherwise.

Explain the conflict: Show which constraints clash, so the user understands.

Propose relaxations: Suggest which constraint to loosen, so a solution becomes possible.

Offer the closest feasible answer: Provide the best achievable result, so users get value.

Let the user prioritize: Ask which constraints matter most, so the trade-off reflects their needs.

Recognize novelty: Detect when a situation is outside known patterns, so it's handled cautiously.

Reason from principles: Apply general reasoning when examples don't fit, so novelty isn't a dead end.

Express appropriate uncertainty: Signal lower confidence on novel cases, so users don't over-rely.

Escalate when needed: Route truly unfamiliar cases to humans, so novelty gets judgment.

Learn from novel cases: Add them to knowledge and examples, so future similar cases are covered.

Respect source preferences: Honor stated distrust where feasible, so users aren't given sources they reject.

Seek alternative sources: Find other support for the answer, so you don't depend on the distrusted one.

Corroborate across sources: Confirm facts from multiple sources, so reliance on any one is reduced.

Be transparent when unavoidable: Disclose if the best source is one they distrust, so they can judge.

Explain source reliability: Share why a source is or isn't trustworthy, so trust is informed.

Verify the reasoning chain: Check that the conclusion follows from the facts, so bad logic is caught.

Ground conclusions in evidence: Ensure conclusions are supported, not just the individual facts, so leaps are prevented.

Check for logical fallacies: Screen reasoning for invalid inferences, so flawed logic surfaces.

Show the derivation: Surface how facts led to the conclusion, so errors are visible.

Evaluate reasoning quality: Test on cases where correct facts can mislead, so this failure mode is measured.

Proceed with reasonable defaults: Assume sensible middle-ground values, so you can still help.

Offer options across cases: Cover the likely possibilities, so users find their situation.

State your assumptions: Make clear what you assumed, so users can correct it.

Avoid over-personalizing: Don't guess at sensitive unknowns, so you don't overstep.

Invite correction: Let users adjust the answer with their specifics, so it can be tailored.

Define success against purpose: Specify what fulfilling the intent means, so you measure the right thing.

Measure outcomes, not just uptime: Track whether user needs are actually met, so running-without-errors isn't mistaken for success.

Capture user satisfaction: Gather whether users got what they needed, so real value is assessed.

Compare against the goal: Judge performance relative to the original purpose, so drift from intent surfaces.

Reassess purpose fit regularly: Check that the agent still serves evolving needs, so it stays aligned with why it exists.