Classify intent type: Determine whether input is a query or an action request, so handling matches.

Use context: Draw on conversation flow to disambiguate, so ambiguous phrasing resolves.

Confirm before acting: Verify intent for consequential commands, so wrong guesses don't cause actions.

Ask when truly unclear: Clarify genuinely ambiguous input, so you don't guess.

Learn from patterns: Improve classification from past cases, so accuracy grows.

Score retrieved context: Assess relevance and sufficiency, so context quality is known.

Gate generation on quality: Proceed only with adequate context, so weak context doesn't produce weak answers.

Improve retrieval on low quality: Re-retrieve or expand when context is poor, so quality improves before generating.

Flag low-context answers: Signal when context was weak, so users judge reliability.

Track context quality over time: Monitor it as a metric, so degradation surfaces.

Identify mandated decisions: Map which decisions legally require humans, so they're never automated.

Gate them explicitly: Block automation on those decisions, so a human must act.

Present clearly for decision: Give the human what they need to decide, so the gate is functional, not a rubber stamp.

Record human involvement: Log that a human decided, so compliance is provable.

Fail closed: Never proceed without the required human step, so the mandate holds.

Anchor to current time: Establish when "now" is, so time-dependent answers are correct.

Fetch time-sensitive data live: Pull current values at query time, so answers reflect the present.

Qualify with timeframe: State what time the answer applies to, so it's not mistaken for permanent.

Avoid stale assumptions: Don't treat time-varying facts as static, so answers stay accurate.

Handle future and past: Interpret temporal references correctly, so "next week" resolves properly.

Persist task context: Store context beyond a single task, so related work reuses it.

Link related tasks: Connect tasks in a series, so context flows between them.

Retrieve relevant history: Pull prior task context when starting a related one, so users don't re-explain.

Detect task relationships: Recognize when tasks connect, so context is carried automatically.

Let users reference prior work: Support references to earlier tasks, so continuity is natural.

Deduplicate requests: Use request IDs to catch duplicates, so repeated delivery doesn't double-process.

Handle out-of-order arrival: Sequence requests explicitly, so order doesn't corrupt state.

Make processing idempotent: Ensure repeats are safe, so duplicate delivery causes no harm.

Acknowledge reliably: Confirm receipt clearly, so senders know not to resend unnecessarily.

Timeout and retry sensibly: Handle lost requests without amplifying duplicates, so recovery is clean.

Infer needed depth: Judge from the question how much answer is wanted, so length fits.

Default to concise: Start short and expand on request, so users aren't overwhelmed.

Match length to complexity: Give simple questions short answers, so effort matches need.

Let users control length: Offer to elaborate, so depth is available on demand.

Lead with the essential: Front-load the core answer, so length doesn't bury the point.

Default to least privilege: Use the intersection of permissions, so access never exceeds any single boundary.

Evaluate per resource: Check permissions for each accessed resource, so access is precise.

Fail closed on ambiguity: Deny when permissions are unclear, so you don't over-grant.

Make boundaries explicit: Define how permissions combine, so behavior is predictable.

Audit access decisions: Log what was permitted and why, so boundaries are verifiable.

Define precedence: Decide when rules override the model and vice versa, so conflicts have a clear resolution.

Let rules handle the certain: Use deterministic logic where correctness is known, so the model doesn't second-guess facts.

Let the model handle nuance: Defer to judgment on ambiguous cases, so rigid rules don't misfire.

Flag disagreements: Surface when rules and model conflict, so hard cases get attention.

Escalate the unresolvable: Route genuine conflicts to a human, so neither is forced wrongly.

Make assumptions explicit: Document what the agent depends on, so they can be checked.

Validate assumptions at runtime: Verify environmental conditions hold, so breaks are detected.

Monitor for drift: Watch for changes in the environment, so silent shifts surface.

Alert on violations: Flag when an assumption breaks, so you react before failures cascade.

Fail safely on broken assumptions: Degrade gracefully when conditions don't hold, so breaks don't cause silent wrong behavior.

Apply backpressure: Signal upstream to slow down, so intake matches capacity.

Bound the queue: Cap queue size, so delay stays bounded.

Shed low-priority load: Drop or defer less important requests, so critical ones are served.

Scale processing: Add capacity when sustained, so the rate gap closes.

Communicate delays: Tell users about wait times, so expectations are managed.

Make assumptions explicit: State what you're assuming, so wrong ones are visible.

Verify when it matters: Confirm key assumptions, so critical answers aren't misdirected.

Avoid over-assuming: Ask rather than guess on important factors, so you don't build on shaky ground.

Adapt when corrected: Update quickly when an assumption proves wrong, so you recover.

Ground in known data: Base assumptions on actual user information, so they're better founded.

Bound context growth: Cap how much state accumulates, so memory doesn't grow unbounded.

Release stale state: Free data no longer needed, so memory is reclaimed.

Externalize large state: Store bulk data outside process memory, so the process stays lean.

Detect leaks: Monitor memory over time, so growth is caught before crashes.

Recycle processes: Restart workers periodically, so accumulated state is cleared safely.

Make objectives explicit: Define all the goals in tension, so none is silently ignored.

Weight them: Assign relative importance, so the balance reflects priorities.

Reason over trade-offs: Have the agent consider objectives jointly, so it optimizes the whole, not one part.

Surface the trade-off: Show what was balanced, so users can adjust.

Evaluate on all objectives: Measure outcomes across every goal, so single-objective optimization is caught.

Measure across user groups: Compare behavior for different users, so disparities surface.

Identify unjustified differences: Distinguish fair personalization from unfair inconsistency, so real problems are found.

Ground shared behavior: Anchor core behavior to consistent logic, so it doesn't vary unfairly.

Audit for bias: Check whether differences correlate with sensitive attributes, so unfairness is caught.

Monitor fairness continuously: Track cross-user consistency, so drift toward unfair treatment surfaces.

Preserve context both ways: Pass full state to the human and back, so nothing is lost in either direction.

Reconcile changes: Merge human edits with agent state, so conflicts are resolved deliberately.

Detect divergence: Recognize when human changes conflict with assumptions, so they're caught.

Re-validate on return: Check the task state when it comes back, so the agent adapts to changes.

Track the handoff: Log who did what, so the exchange is auditable.

Estimate cost upfront: Predict a request's likely cost before running, so expensive ones are flagged.

Use early signals: Detect complexity from the request itself, so prediction is possible before execution.

Gate high-cost requests: Add checks or approval for predicted-expensive ones, so they're controlled.

Set per-request caps: Bound cost regardless of prediction, so surprises are contained.

Learn from history: Refine predictions using past cost data, so estimation improves.

Detect format: Identify the input's actual format, so handling matches it.

Parse defensively: Handle unexpected structures gracefully, so surprises don't crash.

Normalize to a standard: Convert varied formats into a common form, so downstream logic is consistent.

Fail gracefully on unknowns: Return a clear message for unparseable input, so failures are clean.

Learn from surprises: Add newly seen formats to handling, so coverage grows.

Track what's been said: Maintain a record of prior content, so you know what's already covered.

Check before repeating: Compare new content against history, so redundancy is caught.

Reference instead of repeat: Point back to earlier answers, so you don't restate them fully.

Add incremental value: Ensure each response advances the conversation, so nothing is pure repetition.

Summarize when recapping: If recap is needed, condense it, so it's not a verbatim repeat.

Learn user tolerance: Gauge how much each user values speed versus quality, so the trade-off fits them.

Let users choose: Offer a fast-versus-thorough option, so users control the balance.

Adapt by context: Favor speed for quick tasks and quality for deep ones, so the trade-off suits the moment.

Route accordingly: Send requests to fast or thorough paths per preference, so the balance is applied.

Monitor satisfaction: Track whether the trade-off matches user expectations, so it can be tuned.