Set a latency budget: Allocate time across stages, so each step has a bound that keeps the total within SLA.

Enforce hard timeouts: Cap every call, so a slow stage fails fast instead of blowing the whole budget.

Return partial results: Answer with what's ready when time runs out, so users get something within SLA.

Route by complexity: Send simple requests to fast paths, so most traffic stays comfortably under the limit.

Parallelize aggressively: Run independent steps concurrently, so latency is the slowest step, not their sum.

Precompute and cache: Prepare likely results ahead, so hot paths return instantly.

Cap output length: Limit generation, so variable-length responses don't unpredictably breach the SLA.

Monitor tail latency: Track p95 and p99, so SLA breaches surface before users escalate.

Externalize knowledge to retrieval: Keep facts in a refreshable store, so updates don't require retraining the model.

Refresh the index: Re-ingest changed sources regularly, so retrieval reflects the current state of the world.

Prefer live data for volatile facts: Fetch fast-changing values at query time, so answers stay current, not stale.

Version knowledge: Tag content with freshness, so the agent prefers recent information over outdated versions.

Detect staleness: Track how old retrieved content is, so aging knowledge surfaces before it misleads.

Purge outdated content: Remove superseded documents, so retrieval doesn't resurface obsolete facts.

Monitor accuracy over time: Watch for quality decay, so knowledge drift is caught as a measured signal.

Automate update pipelines: Wire sources to auto-ingest, so freshness is maintained without manual effort.

Retrieve, don't stuff: Pull only relevant sections, so you reason over what matters instead of the whole document.

Chunk semantically: Split by structure and meaning, so retrieved pieces are coherent and self-contained.

Summarize hierarchically: Build layered summaries for global questions, so whole-document reasoning doesn't need the full text.

Route by question type: Use retrieval for facts and summaries for overviews, so each question type gets the right method.

Manage the token budget: Cap how much context enters each call, so cost and quality stay controlled.

Position key content well: Place critical info where models attend best, so important context isn't lost in the middle.

Cache processing: Reuse chunked and embedded documents, so long inputs aren't reprocessed every turn.

Cite precisely: Point back to exact sections, so long-context answers stay verifiable.

Validate before passing: Schema-check every output at the boundary, so malformed responses never enter downstream systems.

Contract the interface: Define strict input-output contracts, so consumers know exactly what shape to expect and can reject deviations.

Fail closed: Halt the pipeline on invalid output, so a bad response stops rather than cascading through services.

Add circuit breakers: Isolate failing components, so one broken output doesn't take down the whole chain.

Sanity-check values: Verify outputs against expected ranges, so subtly wrong data is caught before triggering actions.

Buffer with queues: Decouple stages with queues, so a slow or failing consumer doesn't back-pressure everything upstream.

Enable rollback: Make downstream actions reversible, so a bad output's effects can be undone cleanly.

Monitor the boundary: Track output validity and downstream errors, so integration failures surface immediately.

Validate against schema: Check every tool call for valid names and parameters, so invented calls are rejected before execution.

Constrain to available tools: Use function-calling modes that limit choices, so the model can't call tools that don't exist.

Provide clear specs: Give precise tool definitions and examples, so the model has less reason to invent or misremember them.

Reject and re-prompt: Return errors on invalid calls with feedback, so the agent corrects rather than crashing.

Retrieve relevant tools: Surface only applicable tools per query, so the model isn't confused by a large or irrelevant toolset.

Sanitize arguments: Validate parameter types and ranges, so malformed inputs are caught before hitting the real API.

Fail gracefully: Handle invalid calls without crashing, so a hallucination degrades cleanly instead of causing an incident.

Monitor hallucination rate: Track invalid call frequency, so rising hallucinations surface as a fixable, measured signal.

Classify the request: Assess difficulty and stakes upfront, so handling matches what each request actually needs.

Route by priority: Send urgent requests to fast paths and complex ones to thorough paths, so trade-offs fit the situation.

Tier by user: Apply different quality-cost balances per plan, so resources align with what each tier justifies.

Set per-request budgets: Allocate time and cost by importance, so high-stakes requests get more and trivial ones get less.

Escalate when needed: Start cheap and upgrade on low confidence, so you spend more only when it's warranted.

Respect constraints: Honor latency or cost limits per context, so trade-offs stay within each request's requirements.

Make policy explicit: Encode trade-off rules centrally, so decisions are consistent rather than ad hoc.

Measure outcomes: Track quality against cost per path, so trade-off policies are tuned by real results.

Detect expertise level: Infer skill from phrasing and history, so responses match the user's actual knowledge.

Adapt depth: Adjust detail and jargon to the user, so novices aren't overwhelmed and experts aren't slowed down.

Guide novices: Offer suggestions and examples, so unsure users know what to ask and how to start.

Ask clarifying questions: Fill gaps for vague requests, so beginners don't need to phrase things perfectly.

Provide progressive disclosure: Start simple and offer more on request, so depth is available without being forced.

Offer templates: Give starting points for common tasks, so novices get value without crafting perfect prompts.

Explain reasoning: Surface how answers were reached, so less experienced users can learn and trust the output.

Learn from usage: Track where novices struggle, so onboarding and guidance improve over time.

Use idempotency keys: Attach a unique key per action, so retries are deduplicated instead of executing twice.

Confirm before retry: Check whether an action succeeded before retrying, so ambiguous failures don't trigger duplicates.

Make actions idempotent: Design tools so repeats are safe, so accidental re-execution causes no harm.

Track action state: Record what's been executed, so the agent knows an action completed even if the response was lost.

Set clear timeouts: Distinguish slow from failed, so you don't retry a call that actually succeeded.

Separate read from write: Verify state with a read before rewriting, so you act on truth, not assumptions.

Log every call: Record requests and outcomes, so duplicates and discrepancies are detectable and reversible.

Alert on anomalies: Flag duplicate or conflicting actions, so side-effect errors are caught before they compound.

Decouple from the connection: Run tasks server-side independently, so a dropped client connection doesn't kill in-progress work.

Persist task state: Checkpoint progress durably, so a job can resume from where it stopped rather than restarting.

Assign task IDs: Give each job a trackable identifier, so users can reconnect and retrieve status or results later.

Make steps idempotent: Ensure resumed work doesn't duplicate side effects, so recovery is safe to retry.

Use a workflow engine: Adopt durable execution for retries and recovery, so long tasks survive crashes automatically.

Notify on completion: Push results when done, so users get outcomes even after disconnecting mid-task.

Set timeouts and limits: Bound total runtime, so abandoned jobs don't run forever consuming resources.

Clean up state: Expire finished and abandoned tasks, so storage doesn't accumulate stale job data.

Make it stateless: Externalize state so any worker handles any request, enabling horizontal scaling without sticky sessions.

Scale horizontally: Add workers behind a load balancer, so capacity grows by adding instances rather than bigger machines.

Queue and batch: Buffer and group work, so throughput scales without overwhelming downstream providers.

Cache heavily: Reuse results across requests, so scale doesn't translate one-to-one into cost and latency.

Manage rate limits: Centralize provider quotas at a gateway, so scaling traffic doesn't trigger cascading failures.

Isolate components: Decouple retrieval, inference, and tools, so each scales independently to its own bottleneck.

Monitor at scale: Track latency, cost, and errors per component, so bottlenecks surface as volume grows.

Load-test early: Simulate production traffic before launch, so scaling failures are found in testing, not in production.

Use rubric grading: Score against explicit criteria, so answers are judged on substance rather than exact wording.

Apply LLM judges: Have a model grade against rubrics, so open-ended quality scales beyond rigid string matching.

Calibrate against humans: Validate judges on human-labeled data, so automated scores actually reflect real quality judgments.

Check key facts: Verify required elements are present, so correctness is measured by content, not surface form.

Combine methods: Pair judges with rule-based checks, so you catch both subjective quality and objective requirements.

Reduce judge bias: Control for length and position effects, so scoring isn't skewed by irrelevant surface features.

Ensemble for stability: Average multiple judge runs, so noisy single scores don't produce unreliable metrics.

Audit regularly: Spot-check judge decisions against ground truth, so grading quality stays trustworthy over time.

Modularize prompts: Break into reusable, labeled components, so parts can be understood and changed independently.

Document intent: Comment why each section exists, so future editors change it with context, not fear.

Version control: Track history with review, so any change is auditable and reversible if it breaks behavior.

Externalize from code: Store prompts as managed artifacts, so they're editable without deep codebase knowledge.

Template variables: Parameterize dynamic parts, so structure stays stable while inputs change cleanly.

Test every change: Run evals on edits, so modifications are validated rather than made blindly.

Trim complexity: Remove redundant instructions, so the prompt stays simple enough to reason about.

Share ownership: Assign clear owners and reviewers, so no single person is a bottleneck or point of failure.

Persist user profiles: Store durable preferences and facts, so the agent remembers context across separate sessions.

Retrieve on demand: Pull relevant user memory per request, so personalization applies without bloating every prompt.

Scope by identity: Namespace all memory per user, so one person's context never bleeds into another's session.

Store selectively: Save only durable, useful facts, so memory stays clean and doesn't accumulate noise.

Update and expire: Refresh changed preferences and age out stale ones, so personalization stays current, not contradictory.

Apply only when relevant: Use stored facts where they change the answer, so personalization helps rather than feeling intrusive.

Redact sensitive data: Strip PII before persisting, so long-term memory doesn't become a compliance liability.

Let users control it: Allow viewing and deleting memory, so personalization stays transparent and user-governed.

Validate file types: Check format and structure on upload, so malformed or disguised files are rejected before processing.

Scan for threats: Run malware and content scans, so malicious uploads never reach parsing or execution stages.

Enforce size limits: Cap file size and page count, so oversized uploads can't exhaust memory or blow past token budgets.

Sandbox parsing: Extract content in isolation, so a malicious file can't compromise the host or leak into other requests.

Handle failures gracefully: Catch parsing errors cleanly, so a broken file returns a clear message instead of crashing the agent.

Sanitize extracted text: Treat file content as untrusted data, so embedded instructions can't hijack the agent via injection.

Route by type: Use the right extractor per format, so each file type is parsed correctly rather than through one brittle path.

Log processing: Record what was uploaded and extracted, so failures and abuse are traceable and debuggable.

Standardize tool interface: Define a uniform contract for tools, so new ones plug in without bespoke integration each time.

Register dynamically: Load tools from config or a registry, so adding capability doesn't require core code changes.

Adopt a protocol: Use standards like MCP, so external tools integrate through a common interface rather than custom glue.

Validate on registration: Check each tool's schema and behavior, so broken tools are caught before they reach production.

Sandbox new tools: Run additions in isolation first, so untested capabilities can't damage the live system.

Test automatically: Run each tool through an eval suite, so new capabilities are verified before being enabled.

Roll out gradually: Enable new tools for limited traffic first, so issues surface on a small slice before full release.

Retrieve tools per query: Surface only relevant tools, so a growing toolset doesn't degrade selection accuracy or bloat prompts.

Replicate the index: Maintain redundant copies, so a single node failure doesn't take down all retrieval.

Add fallback retrieval: Keep a secondary search path like keyword search, so degraded vector search still returns usable results.

Cache frequent queries: Serve common retrievals from cache, so hot paths survive even when the index is slow or down.

Set timeouts: Bound retrieval latency, so a slow index fails fast instead of hanging the whole request.

Degrade gracefully: Answer with reduced context when retrieval fails, so the agent still responds rather than erroring out.

Monitor health: Track index latency and errors, so problems are caught and failed over before users notice.

Load-balance queries: Distribute across replicas, so no single node becomes a bottleneck under heavy traffic.

Plan recovery: Keep index rebuilds and backups ready, so you can restore quickly after a catastrophic failure.

Centralize storage: Keep all prompts and configs in one managed system, so nothing is scattered or duplicated across the codebase.

Version control: Track history with review and rollback, so every change is auditable and reversible when it breaks something.

Namespace by feature: Scope prompts to owning teams, so changes to one feature can't silently break another's behavior.

Require review: Gate changes behind approval and evals, so conflicting or regressive edits are caught before they ship.

Externalize from code: Store prompts outside application code, so changes don't require redeploys and are easier to manage.

Test on change: Run eval suites against every edit, so prompt changes are validated rather than shipped blindly.

Enable safe experiments: Support per-variant configs, so teams test changes in isolation without affecting shared behavior.

Document ownership: Record who owns and why each prompt exists, so changes are made with full context, not guesswork.

Run local models: Deploy smaller on-device models, so core functionality works without any network connection at all.

Cache aggressively: Store recent results and context locally, so common requests are served offline from cache.

Queue for sync: Buffer requests needing the cloud, so they execute automatically once connectivity returns.

Degrade gracefully: Fall back to reduced capability offline, so users get partial help rather than a dead system.

Tier by capability: Handle simple tasks locally and defer complex ones, so the offline experience stays useful within its limits.

Sync efficiently: Reconcile local and cloud state on reconnect, so offline work merges cleanly without conflicts or data loss.

Preload context: Bundle likely-needed data in advance, so the agent has what it needs before connectivity drops.

Signal state clearly: Show users online versus offline mode, so expectations match the capability currently available.

Test across groups: Evaluate outputs on inputs varying by demographic, so disparate treatment surfaces in testing rather than in public complaints.

Build fairness evals: Measure outcome differences across cohorts, so bias becomes a tracked metric instead of an anecdotal surprise.

Curate balanced examples: Use representative few-shot examples, so the model isn't anchored to skewed patterns that reinforce bias.

Filter biased outputs: Screen responses for discriminatory content, so problematic answers are caught before reaching users.

Audit training and retrieval data: Check sources for skew, so bias isn't silently imported from imbalanced underlying data.

Add human review: Route sensitive decisions to people, so high-stakes fairness calls don't rest solely on the model.

Enable reporting: Give users a way to flag bias, so real-world cases feed directly back into detection and fixes.

Monitor continuously: Track fairness metrics over time, so drift toward biased behavior is caught before it spreads.

Respond incrementally: Stream partial results as they're ready, so users see progress immediately instead of staring at a blank screen.

Acknowledge fast: Return an instant confirmation or preview, so the user knows the request is being handled while deep work continues.

Split fast and slow paths: Answer quick parts immediately and defer heavy reasoning, so simple needs aren't blocked by complex ones.

Run work in background: Offload long tasks to async jobs, so the interface stays responsive while processing completes separately.

Fetch live data just-in-time: Pull real-time values at the moment needed, so answers stay current without slowing the whole pipeline.

Parallelize independent work: Run retrieval, tools, and reasoning concurrently, so total latency is the slowest step, not their sum.

Set expectations: Show status and estimated timing for slow work, so waiting feels intentional rather than broken.

Cache and reuse: Store results of expensive reasoning, so repeat or similar requests return fast instead of recomputing.