Loading...
The agent is designed to serve as a Knowledge Synthesis & Retrieval Specialist. Its primary goal is to transform a massive, unstructured enterprise knowledge base into a searchable, queryable interface that provides precise, verified answers to complex user inquiries.
Success Criteria:
Factuality (Groundedness): 100% of claims made in the answer must be supported by the retrieved documents (Zero Hallucination).
Traceability: Every answer must include granular inline citations or source links to the specific document chunks used.
Reasoning Depth: The ability to synthesize a single answer from information distributed across multiple, disparate documents (e.g., combining a "Security Policy" document with a "Software Setup" guide).
Recall Precision: Successfully retrieving the most relevant "Needle in the Haystack" using hybrid search even when the user uses ambiguous or highly technical terminology.
Level of Autonomy:
The agent operates with Conditional Autonomy (Semi-Autonomous).
Retrieval Autonomy: It has the power to autonomously "step back" and deconstruct a query into sub-queries, deciding which indices (semantic vs. keyword) to prioritize.
Reasoning Autonomy: It can decide if the retrieved context is insufficient and choose to ask the user for clarification rather than providing a guess.
Validation Autonomy: It is self-correcting; it must run its own generated output through a "Hallucination Check" loop before presenting it to the user.
Boundaries and Constraints:
Knowledge Boundary: The agent is strictly prohibited from using "General World Knowledge" or internal LLM training data to answer questions. It must operate solely on the provided enterprise data.
Privacy & Security (RBAC): The agent must respect Role-Based Access Control (RBAC). It can only "see" and retrieve documents that the specific user’s metadata allows (e.g., an Intern agent cannot retrieve "Executive Payroll" chunks).
Output Format: Answers must strictly follow a predefined schema (e.g., Markdown for text, specific citation syntax like [Source 1, p. 4]).
Verbosity Control: The agent must provide the most concise answer possible to fulfill the query, avoiding "corporate fluff" or repetitive explanations.
Abstention Constraint: If the answer is not present in the knowledge base after multiple retrieval attempts, the agent must state "I do not have enough information to answer this" rather than approximating.
The agent uses a ReAct (Reasoning + Action) framework to select tools based on query intent.
Tool IDPurposeInput SchemaOutput Schema
hybrid_search
Retrieve context using Semantic + Keyword matching.
{"query": str, "limit": int}
[{"id": str, "text": str, "source": str}]
relational_query
Fetch structured data (e.g., metadata, dates) via SQL.
{"sql_query": str}
[{"column": value}]
rerank_engine
Score & filter retrieved chunks for precise relevance.
{"query": str, "docs": list}
{"top_hits": list, "conf_score": float}
summarizer
Condense long documents into actionable snippets.
{"doc_id": str}
{"summary": str, "key_points": list}
Selection & Execution Logic
Intent Classification: The agent analyzes the query.
Ambiguous/Conceptual: Calls hybrid_search.
Data/Metric focused: Calls relational_query.
Context Overflow: Calls summarizer before reasoning.
Tool Call: Agent outputs a structured JSON block (e.g., Thought: I need precise setup steps. Action: hybrid_search({"query": "setup guide"})).
Execution: The system executes the code, returning the Observation (raw data) back to the agent.
Refinement: If the observation is insufficient, the agent loops back to Step 1 to select a different tool.
Design the overall agent architecture. Choose an orchestration pattern (single agent, multi-agent, hierarchical). Identify key components and how they interact. Use the diagramming tool to illustrate the architecture.
How does the agent manage memory and context? Define short-term (conversation) and long-term (persistent) memory strategies. How is context window managed? What retrieval mechanisms are used (RAG, vector stores, summarization)?
Deep dive into the agent's reasoning strategy. How does it plan, decide, and self-correct? Discuss prompt engineering, chain-of-thought, reflection loops, failure handling, and tradeoffs.
What guardrails and safety mechanisms does the agent have? Define permission boundaries, human-in-the-loop checkpoints, content filtering, rate limiting, and how the agent handles adversarial inputs or unexpected states.