Ask only what's essential: Request only information that changes the answer, so you don't over-ask.

Batch questions: Ask needed questions together, so users aren't drip-fed queries.

Provide a default answer too: Give a best-guess answer alongside the question, so users get value immediately.

Explain why you're asking: Show how the information improves the answer, so questions feel justified.

Make answering easy: Offer choices rather than open questions, so responding is low-effort.

Detect repetition: Notice when users re-ask similar questions, so unhelpfulness is signaled.

Read frustration signals: Recognize rephrasing and follow-ups indicating dissatisfaction, so you catch it.

Reassess the approach: Try a different tack when prior answers didn't land, so you don't repeat failure.

Ask what's missing: Check what the user actually needs, so you can close the gap.

Learn from the pattern: Feed unhelpful-answer cases back into improvement, so recurring gaps are fixed.

Detect creative intent: Recognize when the user wants novelty, so you adjust.

Increase exploration: Raise diversity for creative tasks, so output isn't safe and predictable.

Avoid clichés: Steer away from the most common outputs, so results feel fresh.

Offer variety: Provide multiple distinct options, so users have creative range.

Balance creativity with the brief: Keep output relevant to the request, so novelty serves the goal.

Assess the value of speed: Judge whether a partial answer now helps, so timing fits the need.

Offer partial with a path to more: Give what's ready and continue toward completeness, so both are served.

Match to urgency: Favor partial-now for urgent needs, complete-later for thorough ones, so it fits context.

Mark completeness: Signal what's partial, so users know what they have.

Let users choose: Allow them to wait for complete or take partial, so they control the trade-off.

Lead with the essential: Give the key answer first, so users grasp the core without overwhelm.

Layer the detail: Offer depth progressively, so completeness is available without forcing it.

Don't omit misleadingly: Include caveats that matter, so brevity doesn't distort.

Summarize accurately: Ensure the short version stays truthful, so comprehensibility doesn't sacrifice accuracy.

Let users go deeper: Enable drilling into detail, so both needs are served.

Use user context: Interpret the question against who's asking, so meaning is resolved.

Detect ambiguity: Recognize when a question means different things, so it's not answered generically.

Disambiguate from history: Use conversation context to pin the meaning, so answers fit.

Ask when needed: Clarify genuinely ambiguous questions, so you don't guess.

Tailor the answer: Respond to the specific meaning for this user, so it's relevant.

Assess per-fact confidence: Estimate certainty for each fact, so uncertainty is tracked granularly.

Propagate uncertainty: Combine individual uncertainties into overall confidence, so the answer reflects the whole.

Identify weak links: Recognize when one uncertain fact undermines the conclusion, so overconfidence is avoided.

Communicate compound uncertainty: Express how uncertainty accumulates, so users understand reliability.

Verify critical facts: Firm up the facts that most affect the answer, so uncertainty is reduced where it matters.

Track the original goal: Keep the initial request in view, so drift is measurable.

Detect divergence: Recognize when the task has drifted from intent, so it's caught.

Reconfirm on significant drift: Check with the user when the task has strayed, so you don't proceed misaligned.

Realign or restart: Course-correct back toward the goal, so drift is fixed.

Distinguish drift from evolution: Tell genuine scope changes from accidental drift, so you don't over-interrupt.

Detect the false premise: Recognize when the question rests on an error, so it's not answered as-is.

Correct it respectfully: Point out the mistaken premise gently, so the user isn't embarrassed.

Address the real need: Answer what they were actually trying to get at, so the correction is helpful.

Explain the correction: Show why the premise is wrong, so it's credible.

Avoid answering the flawed question directly: Don't build a wrong answer on a false premise, so you don't reinforce the error.

Schedule deliberate reviews: Revisit core design choices on a cadence, so they don't go unquestioned.

Re-validate assumptions: Check whether the original premises still hold, so stale foundations surface.

Compare against alternatives: Assess newer approaches against the current one, so you know if better options exist.

Weigh the cost of change: Balance the benefit of a new approach against migration cost, so re-examination is realistic.

Act on findings: Commit to change when justified, so re-examination isn't just an exercise.

Recognize collaborative tasks: Detect when a task needs back-and-forth, so you don't force a single answer.

Break into turns: Structure the task as a collaboration, so it unfolds naturally.

Maintain task state: Track progress across turns, so the collaboration is coherent.

Guide the next step: Tell the user what's needed next, so the collaboration moves forward.

Confirm at checkpoints: Verify alignment along the way, so the task stays on track.

Surface action costs: Note what acting on the answer requires, so users can weigh it.

Present trade-offs: Show what each option costs and gains, so decisions are informed.

Flag significant commitments: Highlight when acting is costly or hard to reverse, so users are aware.

Right-size the caveats: Match cost warnings to their significance, so you don't over-caveat trivial actions.

Support the decision: Give users what they need to weigh costs, so they can choose well.

Prioritize honesty: Give the accurate answer even when unwelcome, so users aren't misled.

Deliver with tact: Frame hard truths considerately, so honesty isn't needlessly harsh.

Explain the reasoning: Show why the answer is what it is, so it's credible, not arbitrary.

Offer constructive paths: Provide what the user can do about it, so the answer is actionable.

Don't soften into inaccuracy: Avoid diluting the truth to please, so accuracy holds.

Detect the request type: Recognize whether they want a recommendation or a menu, so you respond right.

Read decision signals: Interpret phrasing like "which should I" versus "what are my options," so intent is clear.

Default to a recommendation with rationale: Give a pick and the reasoning, so both preferences get partial value.

Offer to expand: Provide options if they wanted a decision, or a pick if they wanted options, so you cover both.

Ask when genuinely unclear: Clarify if the request is ambiguous, so you don't guess.

Explain the restriction: Tell the user why the capability is limited, so the refusal is understood.

Verify legitimacy where possible: Provide a path to establish valid need, so real cases can be served.

Offer an approval route: Enable escalation for legitimate access, so restrictions aren't absolute dead ends.

Suggest alternatives: Provide other ways to meet the need, so users aren't stuck.

Keep restrictions principled: Apply them consistently, so exceptions are deliberate, not arbitrary.

Normalize input: Standardize whitespace and formatting before processing, so trivial variation is removed.

Focus on content: Base behavior on meaning, not formatting, so trivial differences don't matter.

Test with variations: Include formatting variants in tests, so sensitivity surfaces.

Strip incidental formatting: Remove non-meaningful formatting, so it doesn't influence behavior.

Monitor consistency: Track output stability across formatting variants, so sensitivity is measured.

Acknowledge the disagreement: Present that experts differ, so you don't fake a false consensus.

Present the main positions: Lay out the competing views fairly, so users see the landscape.

Explain the basis of each: Show why each position is held, so the disagreement is understood.

Avoid false certainty: Don't pick a side as settled fact, so you don't misrepresent the state of knowledge.

Help users navigate: Give them what they need to form their own view, so they're equipped to decide.

Smooth output timing: Buffer to deliver at a steady rate, so downstream isn't hit with bursts.

Bound latency variance: Cap slow cases, so output timing stays predictable.

Decouple with queues: Place a buffer between the agent and downstream, so rate mismatches are absorbed.

Apply backpressure: Signal upstream when downstream can't keep up, so rates align.

Monitor rate consistency: Track output timing, so variance surfaces.

Assess real urgency: Judge actual time-sensitivity, not just urgent-sounding phrasing, so effort matches need.

Confirm when unclear: Check whether speed truly matters, so you don't wrongly rush.

Don't sacrifice quality needlessly: Maintain quality when urgency isn't real, so answers aren't rushed for nothing.

Respond fast when it counts: Prioritize speed for genuine urgency, so real time pressure is served.

Let users set priority: Allow explicit urgency signals, so it's not only inferred.

Monitor continuously: Keep tracking quality even when things seem fine, so erosion is caught early.

Refresh evals regularly: Keep the test set current with real usage, so quality is measured against reality.

Watch for gradual drift: Track trends, so slow decline surfaces before it's a problem.

Keep improving proactively: Invest in quality even without a crisis, so complacency doesn't set in.

Re-validate assumptions: Periodically question what you believe about the system, so stale assumptions are caught.

Maintain accountability: Keep clear ownership of quality, so it doesn't slip through the cracks.