Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Use-case qualification. Assess whether this workflow actually needs an autonomous agent rather than deterministic automation; create a decision matrix.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Assess whether this workflow actually needs an autonomous agent rather than deterministic automation; create a decision matrix.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Stakeholder requirements. Turn stakeholder interviews into functional requirements, nonfunctional requirements, constraints and sign-off questions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Turn stakeholder interviews into functional requirements, nonfunctional requirements, constraints and sign-off questions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Agent boundary mapping. Define user, model, tool, data and human responsibility boundaries with a trust-boundary diagram in text.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define user, model, tool, data and human responsibility boundaries with a trust-boundary diagram in text.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Single-agent blueprint. Design a minimal single-agent architecture with state, tools, termination conditions and failure modes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a minimal single-agent architecture with state, tools, termination conditions and failure modes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Agent versus workflow. Compare fixed workflow, router, planner-executor and multi-agent options using evidence-based criteria.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Compare fixed workflow, router, planner-executor and multi-agent options using evidence-based criteria.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Success metrics. Define measurable success, task completion, escalation, cost, latency and error metrics with baselines.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define measurable success, task completion, escalation, cost, latency and error metrics with baselines.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Risk register. Create an agent project risk register with likelihood, impact, mitigation, owner and review cadence.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create an agent project risk register with likelihood, impact, mitigation, owner and review cadence.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Acceptance criteria. Write testable acceptance criteria, including negative cases, for a proposed agent.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write testable acceptance criteria, including negative cases, for a proposed agent.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: System context map. List upstream systems, downstream dependencies, data contracts and operating assumptions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: List upstream systems, downstream dependencies, data contracts and operating assumptions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in agent discovery & architecture.

TASK: Architecture review. Review an architecture proposal for complexity, observability, rollback and maintainability.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Review an architecture proposal for complexity, observability, rollback and maintainability.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: System instruction specification. Draft a concise system instruction with role, authorized scope, refusal boundary and priority rules.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Draft a concise system instruction with role, authorized scope, refusal boundary and priority rules.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Task prompt contract. Convert a vague user task into explicit inputs, outputs, constraints and success criteria.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Convert a vague user task into explicit inputs, outputs, constraints and success criteria.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Few-shot examples. Design representative positive, edge and failure examples without leaking expected labels.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design representative positive, edge and failure examples without leaking expected labels.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Context budget. Propose a token allocation for system, retrieved context, memory, tool results and output.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Propose a token allocation for system, retrieved context, memory, tool results and output.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Structured output. Specify a typed JSON schema, validation strategy and recovery from invalid model output.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify a typed JSON schema, validation strategy and recovery from invalid model output.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Prompt injection defense. Create a threat-aware handling policy for untrusted retrieved text and tool content.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a threat-aware handling policy for untrusted retrieved text and tool content.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Grounding instructions. Draft instructions that distinguish sourced evidence, inference and unknowns.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Draft instructions that distinguish sourced evidence, inference and unknowns.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Prompt versioning. Design prompt identifiers, change log fields, regression tests and rollback rules.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design prompt identifiers, change log fields, regression tests and rollback rules.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Localization of prompts. Adapt an agent prompt for a specified locale while preserving safety and task semantics.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Adapt an agent prompt for a specified locale while preserving safety and task semantics.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in prompt & context engineering.

TASK: Prompt review rubric. Score clarity, specificity, reliability, privacy, testability and unnecessary verbosity.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Score clarity, specificity, reliability, privacy, testability and unnecessary verbosity.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Source inventory. Create a data-source inventory with ownership, permissions, formats, freshness and retention.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a data-source inventory with ownership, permissions, formats, freshness and retention.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Document ingestion. Design ingestion for PDFs, HTML and docs with parsing, cleaning, metadata and error logging.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design ingestion for PDFs, HTML and docs with parsing, cleaning, metadata and error logging.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Chunking experiment. Compare chunk sizes, overlap and semantic segmentation through a reproducible evaluation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Compare chunk sizes, overlap and semantic segmentation through a reproducible evaluation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Embedding selection. Create a selection rubric for embedding models based on language, cost, domain and privacy.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a selection rubric for embedding models based on language, cost, domain and privacy.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Hybrid retrieval. Plan keyword and vector retrieval with query rewriting and fusion criteria.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan keyword and vector retrieval with query rewriting and fusion criteria.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Metadata filters. Define safe filters for tenant, user role, source date and document access permissions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define safe filters for tenant, user role, source date and document access permissions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Reranking. Plan a reranking stage and measurable comparison against baseline retrieval.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan a reranking stage and measurable comparison against baseline retrieval.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Citation generation. Define citation IDs, snippet evidence, clickable source references and unsupported-claim handling.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define citation IDs, snippet evidence, clickable source references and unsupported-claim handling.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: RAG evaluation set. Build grounded question-answer pairs including no-answer and stale-source cases.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Build grounded question-answer pairs including no-answer and stale-source cases.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in rag & knowledge engineering.

TASK: Knowledge refresh. Design re-indexing, deletion propagation, freshness checks and data lineage.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design re-indexing, deletion propagation, freshness checks and data lineage.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Tool catalog. Document available tools with input schemas, output types, authentication and side effects.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Document available tools with input schemas, output types, authentication and side effects.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Function schema. Write a strict function-call schema with required fields, enums and validation rules.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write a strict function-call schema with required fields, enums and validation rules.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Tool selection. Define when an agent should use a tool, ask a question or answer without tool calls.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define when an agent should use a tool, ask a question or answer without tool calls.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: API integration plan. Map rate limits, pagination, retries, timeouts and idempotency for a third-party API.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Map rate limits, pagination, retries, timeouts and idempotency for a third-party API.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Webhook workflow. Design webhook verification, replay protection, asynchronous handling and audit events.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design webhook verification, replay protection, asynchronous handling and audit events.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Permission design. Define least-privilege permissions and per-user authorization checks for each tool.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define least-privilege permissions and per-user authorization checks for each tool.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: High-impact confirmation. Require explicit human confirmation before sending, spending, deleting or changing records.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Require explicit human confirmation before sending, spending, deleting or changing records.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Tool error recovery. Create recoverable versus terminal error categories and user-facing fallback messages.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create recoverable versus terminal error categories and user-facing fallback messages.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Tool output sanitization. Specify how to parse untrusted tool responses without treating them as instructions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify how to parse untrusted tool responses without treating them as instructions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in tools, apis & function calling.

TASK: Mock tool harness. Design deterministic mocks to test agent tool calls without touching production systems.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design deterministic mocks to test agent tool calls without touching production systems.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: State schema. Design a typed state object for a graph-based agent including provenance and error fields.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a typed state object for a graph-based agent including provenance and error fields.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Graph nodes. Break a requirement into nodes with inputs, outputs, side effects and test contracts.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Break a requirement into nodes with inputs, outputs, side effects and test contracts.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Conditional routing. Define conditional edges for task type, confidence, failure and escalation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define conditional edges for task type, confidence, failure and escalation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Checkpointing. Design checkpoints and resume semantics for interrupted agent runs.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design checkpoints and resume semantics for interrupted agent runs.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Human-in-the-loop. Add approval and edit checkpoints before irreversible actions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Add approval and edit checkpoints before irreversible actions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Subgraph composition. Propose reusable subgraphs for retrieval, verification and response formatting.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Propose reusable subgraphs for retrieval, verification and response formatting.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Retry and backoff. Set retry limits, exponential backoff and dead-letter outcomes for failing nodes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Set retry limits, exponential backoff and dead-letter outcomes for failing nodes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Streaming UX. Plan user-visible streaming events without leaking internal state or credentials.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan user-visible streaming events without leaking internal state or credentials.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Graph test cases. Write node-level, edge-level and end-to-end cases for a graph implementation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write node-level, edge-level and end-to-end cases for a graph implementation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in langchain & langgraph workflows.

TASK: Migration review. Plan a safe migration from a linear chain to graph orchestration with parity tests.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan a safe migration from a linear chain to graph orchestration with parity tests.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Memory need assessment. Distinguish context window, task state, episodic memory and long-term preferences.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Distinguish context window, task state, episodic memory and long-term preferences.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Session memory schema. Specify a bounded session-memory schema with expiry and access controls.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify a bounded session-memory schema with expiry and access controls.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Memory extraction. Design a conservative rule for extracting relevant durable facts with consent.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a conservative rule for extracting relevant durable facts with consent.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Memory retrieval. Define ranking, freshness and contradiction handling for recalled memory.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define ranking, freshness and contradiction handling for recalled memory.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Memory correction. Design user-facing review, correction and deletion workflows.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design user-facing review, correction and deletion workflows.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: State compaction. Create a loss-aware conversation summary method preserving key constraints.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a loss-aware conversation summary method preserving key constraints.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Sensitive-data policy. List sensitive categories to exclude or minimize in persistent memory.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: List sensitive categories to exclude or minimize in persistent memory.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Cross-user isolation. Plan tenant isolation tests for memory and checkpoints.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan tenant isolation tests for memory and checkpoints.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Memory evaluation. Build tests for precision, relevance, staleness and privacy leakage.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Build tests for precision, relevance, staleness and privacy leakage.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in memory & state management.

TASK: Failure recovery. Specify behavior when the memory store is unavailable or inconsistent.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify behavior when the memory store is unavailable or inconsistent.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Need for multi-agent. Evaluate whether specialist agents provide measurable benefit over one agent.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Evaluate whether specialist agents provide measurable benefit over one agent.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Role contracts. Define planner, researcher, executor and verifier roles with clear authority limits.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define planner, researcher, executor and verifier roles with clear authority limits.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Handoff protocol. Specify message envelope, task ID, evidence links, state and acceptance conditions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify message envelope, task ID, evidence links, state and acceptance conditions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Supervisor policy. Design a supervisor that delegates, monitors and stops loops.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a supervisor that delegates, monitors and stops loops.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Conflict resolution. Create a protocol for contradictory agent conclusions and uncertainty.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a protocol for contradictory agent conclusions and uncertainty.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Parallel execution. Identify independent tasks safe to run concurrently with dependency controls.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Identify independent tasks safe to run concurrently with dependency controls.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Shared context. Minimize shared state and prevent unnecessary exposure between specialist agents.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Minimize shared state and prevent unnecessary exposure between specialist agents.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Verifier agent. Design an independent verifier using external evidence and a transparent rubric.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design an independent verifier using external evidence and a transparent rubric.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Budget limits. Enforce per-agent token, cost, retry and duration budgets.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Enforce per-agent token, cost, retry and duration budgets.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in multi-agent collaboration.

TASK: Multi-agent benchmarks. Compare quality, latency and cost against a single-agent baseline.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Compare quality, latency and cost against a single-agent baseline.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Golden dataset. Create a diverse benchmark with representative, adversarial and no-answer cases.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a diverse benchmark with representative, adversarial and no-answer cases.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Task completion rubric. Define pass/fail criteria and partial-credit rules for agent outcomes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define pass/fail criteria and partial-credit rules for agent outcomes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Tool correctness test. Check tool choice, arguments, permissions, sequencing and error handling.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Check tool choice, arguments, permissions, sequencing and error handling.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: RAG faithfulness test. Evaluate whether response claims are supported by retrieved evidence.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Evaluate whether response claims are supported by retrieved evidence.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Regression suite. Create an automated suite run after model, prompt or tool changes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create an automated suite run after model, prompt or tool changes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Trace design. Specify structured traces with safe redaction and correlation IDs.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify structured traces with safe redaction and correlation IDs.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Cost-latency dashboard. Define dashboards for per-task cost, latency distribution and success rate.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define dashboards for per-task cost, latency distribution and success rate.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Human evaluation. Design blinded evaluator instructions, calibration and adjudication.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design blinded evaluator instructions, calibration and adjudication.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Failure taxonomy. Categorize hallucination, tool misuse, retrieval miss, policy breach and timeout.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Categorize hallucination, tool misuse, retrieval miss, policy breach and timeout.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in evaluation, testing & observability.

TASK: Experiment report. Summarize A/B evaluation with sample size, confidence limits and release decision.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Summarize A/B evaluation with sample size, confidence limits and release decision.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Threat model. Produce a defensive threat model of prompt injection, data leakage and tool abuse.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Produce a defensive threat model of prompt injection, data leakage and tool abuse.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Input boundary. Define validation, input size limits and untrusted-content treatment.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define validation, input size limits and untrusted-content treatment.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Output policy. Design output validation for restricted data, fabricated claims and unsafe actions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design output validation for restricted data, fabricated claims and unsafe actions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: PII minimization. Specify PII collection, redaction, retention and access requirements.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify PII collection, redaction, retention and access requirements.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Credential handling. Design secret storage and rotation rules; never insert credentials into prompts.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design secret storage and rotation rules; never insert credentials into prompts.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Tenant authorization. Test retrieval and tool scopes for cross-tenant disclosure.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Test retrieval and tool scopes for cross-tenant disclosure.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Human oversight. Map decisions requiring human review and escalation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Map decisions requiring human review and escalation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Audit trail. Define tamper-evident records for tool invocations and approvals.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define tamper-evident records for tool invocations and approvals.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Incident playbook. Create response steps for agent errors, leaks and unauthorized actions.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create response steps for agent errors, leaks and unauthorized actions.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in safety, privacy & guardrails.

TASK: Red-team plan. Build safe test scenarios to evaluate controls without attacking third-party systems.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Build safe test scenarios to evaluate controls without attacking third-party systems.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Environment design. Plan local, staging and production separation with configuration controls.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan local, staging and production separation with configuration controls.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Deployment checklist. Build a preflight checklist for tests, permissions, observability and rollback.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Build a preflight checklist for tests, permissions, observability and rollback.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Version management. Specify version pinning for models, dependencies, prompts and schemas.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify version pinning for models, dependencies, prompts and schemas.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Queue architecture. Design asynchronous jobs, idempotency, backpressure and cancellation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design asynchronous jobs, idempotency, backpressure and cancellation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Caching policy. Identify safe caching opportunities and invalidation rules for sensitive responses.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Identify safe caching opportunities and invalidation rules for sensitive responses.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Rate-limit handling. Plan quotas, burst protection and graceful degradation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan quotas, burst protection and graceful degradation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Service reliability. Define SLOs, alert thresholds, runbooks and on-call expectations.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Define SLOs, alert thresholds, runbooks and on-call expectations.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Rollback plan. Specify model/prompt rollback triggers and compatibility checks.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify model/prompt rollback triggers and compatibility checks.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Disaster recovery. Plan backup, restore and dependency outage drills.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan backup, restore and dependency outage drills.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in deployment, scalability & operations.

TASK: Operational handoff. Write an operator runbook for monitoring, support and change approval.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write an operator runbook for monitoring, support and change approval.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Agent onboarding. Write onboarding that sets realistic capability and privacy expectations.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write onboarding that sets realistic capability and privacy expectations.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Conversation UX. Design clarification questions, progress messages and error recovery states.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design clarification questions, progress messages and error recovery states.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Escalation experience. Create seamless handoff to a human with context minimization.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create seamless handoff to a human with context minimization.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: CRM assistant. Scope an approved CRM assistant with read/write controls and confirmation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Scope an approved CRM assistant with read/write controls and confirmation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Support agent. Design a source-grounded support assistant with refusal on missing policy.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a source-grounded support assistant with refusal on missing policy.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Research assistant. Build a workflow for evidence collection, synthesis and citation review.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Build a workflow for evidence collection, synthesis and citation review.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Document agent. Design document classification, extraction and human QA.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design document classification, extraction and human QA.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Analytics assistant. Specify safe SQL/read-only analytics workflows and result validation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Specify safe SQL/read-only analytics workflows and result validation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Accessibility review. Audit agent UI for keyboard, screen reader and plain-language support.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Audit agent UI for keyboard, screen reader and plain-language support.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in product ux & business integrations.

TASK: Product experiment. Plan a usability study and measurable activation/retention experiment.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Plan a usability study and measurable activation/retention experiment.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Discovery proposal. Draft a scoped proposal stating deliverables, assumptions, exclusions and approvals.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Draft a scoped proposal stating deliverables, assumptions, exclusions and approvals.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Pilot definition. Design a small paid pilot with baseline, benchmark and exit criteria.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Design a small paid pilot with baseline, benchmark and exit criteria.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Implementation roadmap. Create milestone plan from prototype to production with dependencies.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create milestone plan from prototype to production with dependencies.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Project estimate. Break down engineering effort, API cost and uncertainty transparently.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Break down engineering effort, API cost and uncertainty transparently.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Demo script. Write a live demo showcasing happy path, edge case and human escalation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Write a live demo showcasing happy path, edge case and human escalation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Case study. Turn a real or clearly labeled simulated project into a truthful case study.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Turn a real or clearly labeled simulated project into a truthful case study.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Portfolio architecture. Structure a portfolio page with problem, stack, diagram, evaluation and outcomes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Structure a portfolio page with problem, stack, diagram, evaluation and outcomes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: GitHub README. Create a reproducible README with setup, architecture, test and privacy notes.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Create a reproducible README with setup, architecture, test and privacy notes.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Remote interview practice. Generate practical interview questions on agent design and trade-offs.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Generate practical interview questions on agent design and trade-offs.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.

Act as a senior AI agent and LLM application engineer specializing in client delivery & remote portfolio.

TASK: Client handover. Prepare maintenance, ownership, acceptance and operational documentation.

PROJECT INPUTS (replace placeholders):
- Business use case: [USE_CASE]
- Users and roles: [USERS_AND_PERMISSIONS]
- Existing stack and integrations: [TECH_STACK]
- Data sources and sensitivity: [DATA_SOURCES_AND_CLASSIFICATION]
- Constraints: [BUDGET_LATENCY_COMPLIANCE]
- Available evidence, code or requirements: [PASTE_RELEVANT_MATERIAL]

DELIVERABLES:
1. Explain assumptions and identify missing inputs; do not invent production facts or test results.
2. Produce a detailed, task-specific solution for: Prepare maintenance, ownership, acceptance and operational documentation.
3. Include concrete examples (schemas, pseudocode, workflow steps, test fixtures or tables as appropriate), and label illustrative data.
4. Describe relevant edge cases, failure handling, security/privacy boundaries and human approval steps.
5. Provide implementation steps, measurable acceptance criteria and a focused validation checklist.
6. Finish with open decisions and the next smallest verifiable action.

Use clear Markdown headings. Never claim to have accessed tools, systems, sources, or logs unless the evidence is supplied. Never include actual credentials. Ask for authorization before actions affecting live systems.