Agent Development

Here is a restructured and rephrased guide for constructing AI capabilities, designed as a chronological blueprint for developers.

Capability Design Blueprint

Follow this mechanical framework to ensure your AI agent operates predictably and accurately.

Phase 1: Activation and Boundaries

• Launch Criteria: Document the exact user goal or prompt that wakes up this specific function.
• Exclusions: Draw a hard, explicit line detailing what actions and topics are strictly prohibited or unsupported by this function.

Phase 2: Data Prerequisites and Deliverable Structure

• Ingestion: Catalog every piece of incoming information required to run the task (e.g., conversation history, system variables, user-provided text).
• Final Form: Dictate the rigid architecture of the final response. Whether the requirement is a coded data payload or a highly specific text template, the architectural layout must be absolute.

Phase 3: The Operational Algorithm

• Sequential Logic: Map out the AI’s workflow as a strict, step-by-step algorithm or flowchart.
• Concrete Directives: Eliminate subjective verbs. Command the AI using definitive operations (e.g., "Isolate the numerical values," "Match the primary key to the database record").

Phase 4: Factual Anchoring and Integrations

• External Utilities: List every external utility the agent must connect with to perform its job (such as internet browsing, proprietary endpoints, or internal knowledge bases).
• Fabrication Prevention: Mandate the use of these utilities to guarantee the agent builds its response on verifiable reality rather than generating invented information.

Phase 5: Contingency Protocols

• Anomaly Management: Script exact fallback behaviors for when things go wrong.
• Prescribed Remedies: If parameters are absent, integrations crash, or unusual scenarios arise, the instructions must dictate the exact remedy (e.g., "Prompt the human for the missing variable" or "Generate failure message ID-404").

Phase 6: Design Anti-Patterns (Prohibited Practices) To ensure success, developers must strictly avoid the following structural flaws:

1. Subjectivity: Never use open-ended, broad, or unmeasurable instructions.
2. Function Overloading: Never bundle unrelated operations together. A single capability must be focused entirely on one core job.
3. Untestable Results: Never deploy a function without establishing a definitive, independent method for validating and scoring its final output.

Grounding (do this at runtime)

Do NOT answer precise facts (codes, identifiers, sections, current values) from memory — use the document/data the user provides, and base the answer only on what it returns.