Agentic AI — Quick Reference#

One-Line Definition#

An agent is an LLM that perceives its environment, reasons about what to do, uses tools to act, and observes the results — repeating this loop until a task is complete or a defined limit is reached.

When to Use Agents / When NOT to Use#

Agent Paradox: The harder the task, the more an agent helps — and the harder it is to verify the agent's work. Plan evaluation before you deploy.

Core Concepts#

Framework Comparison#

Tool Design Rules#

{
    "name": "action_verb_noun",           # Unambiguous action name
    "description": (
        "One sentence: what it does. "
        "Second sentence: when to use it vs. similar tools. "
        "Third sentence: what it returns or error behavior."
    ),
    "input_schema": {
        "type": "object",
        "properties": {
            "required_param": {
                "type": "string",
                "description": "Precise description with format, example if not obvious",
            },
            "optional_param": {
                "type": "integer",
                "description": "What it controls (default X, range Y–Z)",
                "default": 3,
            },
        },
        "required": ["required_param"],
    },
}

Tool Side-Effect Classification:

Memory System Summary#

LangGraph Patterns#

from typing import Annotated
import operator
from typing_extensions import TypedDict

# State schema — Annotated list accumulates; other fields replace (last-write-wins)
class WorkflowState(TypedDict):
    messages: Annotated[list[dict], operator.add]  # accumulates
    patient_id: str                                # replaced
    result: dict                                   # replaced

# Node = pure function: state dict → partial state dict
def my_node(state: WorkflowState) -> dict:
    # ... do work ...
    return {"result": {"key": "value"}, "messages": [{"node": "my_node", "status": "done"}]}

# Conditional edge routing
def route_fn(state: WorkflowState) -> Literal["node_a", "node_b"]:
    return "node_a" if state["result"].get("ok") else "node_b"

# Checkpointer choice
from langgraph.checkpoint.memory import MemorySaver      # dev/test only
from langgraph.checkpoint.postgres import PostgresSaver  # production

# HITL pattern
graph = builder.compile(
    checkpointer=PostgresSaver.from_conn_string(CONN),
    interrupt_before=["human_review_node"],
)

# Phase 1: Run to interrupt
result = graph.invoke(initial_state, {"configurable": {"thread_id": "run-001"}})

# Phase 2: Resume after human input
result = graph.invoke(
    {"human_decision": "approved"},
    {"configurable": {"thread_id": "run-001"}}
)

Multi-Agent Topology Quick Selection#

HITL Design Checklist#

• [ ] Identify which workflow nodes require human review (policy-based, risk-based, confidence-based, anomaly-based)
• [ ] Design interrupt point before any external action is taken
• [ ] Persist state to durable storage (PostgreSQL) before notifying reviewer
• [ ] Define reviewer role and authorization for each HITL trigger type
• [ ] Define SLA for review; implement escalation path for SLA breach
• [ ] Write all decisions to immutable audit log (reviewer ID, timestamp, decision, rationale)
• [ ] Test the resume path explicitly — the interrupt is only half the pattern

MCP Quick Reference#

Transport: stdio (local subprocess) vs. HTTP+SSE (remote, multi-user)

Security rule: Tool authorization enforced at the MCP server — the client is not a security boundary.

Security Quick Reference#

Defense hierarchy (most to least reliable):

1. Tool authorization enforcement (independent of model reasoning)
2. Input/output validation (detects known patterns)
3. System prompt hardening (reduces model compliance with injection)

Observability Checklist#

• [ ] Span-based tracing: one root span per workflow, child spans per node and tool call
• [ ] LLM call instrumentation: model, input tokens, output tokens, latency
• [ ] Compliance audit log: separate, immutable; every tool call and HITL decision logged
• [ ] PHI masked before transmission to third-party trace stores
• [ ] Quality gate defined and monitored (automated evaluation pipeline)
• [ ] Key metrics: success rate, HITL trigger rate, quality score, P95 latency, token cost

Common Interview Questions#

1. When would you choose an agent over a chain? — When the task requires dynamic tool selection based on results; when control flow cannot be determined in advance.

1. What is the "agent paradox"? — Complex tasks benefit most from agents, but are also hardest to evaluate. Always define evaluation before deployment.

1. How does LangGraph's checkpointing enable HITL? — interrupt_before pauses execution and returns control; PostgresSaver persists state durably; the caller resumes by invoking graph.invoke() with the human decision in state.

1. Why enforce tool authorization at the MCP server rather than relying on the agent? — The LLM is not a reliable security boundary — it can be manipulated by prompt injection. The MCP server is code; it enforces authorization independent of the model's reasoning.

1. What are the four HITL trigger categories? — Confidence-based (agent uncertainty), risk-based (action side-effect level), policy-based (business rule mandates review regardless of confidence), anomaly-based (agent detects unexpected state).

1. What is the M×N problem MCP solves? — Without a standard protocol, M AI applications × N backend systems = M×N integrations. With MCP: M clients + N servers; each addition requires one implementation, not M or N.

See Also#

• Agent Architecture Fundamentals
• Tool Design Patterns
• LangGraph Deep Dive
• Human-in-the-Loop Design
• Agentic Security
• Multi-Agent Enterprise Reference Architecture