ImageFirm · AI Intelligence Library

30 AI Agents
Every Engineer Must BuildUPGRADED 2026

A research-grounded, production-ready reference. Blueprint refined with field studies, architectural surveys, and ImageFirm's ethical AI principles.

Human intelligence amplified. Not replaced.

From Blueprint to Production Reality

The original October 2026 engineering reference mapped 30 essential agent types across foundation, intelligence, multimodal, specialized, domain, and integration layers. This ImageFirm upgrade synthesizes that pedagogical structure with current best practices from peer-reviewed surveys, production field studies (G2 2026), framework evaluations (LangGraph, CrewAI, Microsoft Agent Framework), and ImageFirm's own architecture work.

Start Simple

Default to a single capable agent with well-scoped tools. Add multi-agent orchestration only when you can name the specific bottleneck (parallelism, permission boundaries, tool overload).

Explicit Control

Prefer hierarchical or graph-based orchestration (LangGraph strength) over open conversational multi-agent for production. Make handoffs structured and inspectable.

Observability First

Treat agents as non-deterministic microservices. Instrument every step, enforce budgets, and design for human-in-the-loop on high-stakes paths.

Architecture Map — For All 30

Aligned with ImageFirm's 9-layer production model and the five-module academic consensus (profile, memory, planning, action, security).

FOUNDATION LAYER — BUILD FIRST

Decision · Planning · Memory · Retrieval · Tools · Docs · Safety · Infra

Agents 1–8. Autonomous decision, planning, memory-augmented, knowledge retrieval, document intelligence, scientific research, tool-using, agentic workflow.

INTELLIGENCE + MULTIMODAL

Data · Reasoning · Code · Vision · Audio · Content · Collab · Workflow

Agents 9–20. Analysis, verification, problem solving, code generation, security, self-improving, conversational, content, recommendation, vision, audio, physical sensing.

SPECIALIZED + DOMAIN + INTEGRATION

Analytics · Health · Finance · Legal · Education · Ops · Collective · Embodied

Agents 21–30. Ethical reasoning, explainability, healthcare, scientific discovery, financial, legal, education, collective intelligence, embodied, domain-transforming.

ImageFirm Design Principles: Ground before generating · Least privilege by default · Measure what matters (success, safety, cost, value) · Keep humans in command on high-stakes decisions.

The 30 Agents — Upgraded Descriptions

Each agent retains its original pedagogical role. Annotations reflect 2026 production realities: MCP for tools, layered memory, explicit stopping conditions, evaluation loops, and human oversight where required.

Foundation Agents 1–8

01
Autonomous Decision Agent
LOW–MED complexity

Makes decisions, initiates and acts without per-step human approval. Upgrade: Bound the action space strictly; require explicit success criteria and a hard turn/cost budget. Prefer structured outputs over free-form.

02
Planning Agent
MED complexity

Breaks goals into executable steps and orchestrates sub-tasks. Upgrade: Use explicit graph or hierarchical decomposition. Validate plan against constraints before execution. Common failure: infinite planning loops — enforce depth limits.

03
Memory-Augmented Agent
MED complexity

Short + long term memory across sessions. Knows what happened. Upgrade: Layered memory (working context, episodic, semantic/vector). Consent-aware and editable. Context rot is a leading failure mode — implement selective retrieval and summarization.

04
Knowledge Retrieval Agent
MED complexity

Searches docs, wikis, databases and returns precise, cited information. Upgrade: Retrieval quality often the bottleneck, not reasoning. Use hybrid search, provenance tracking, and freshness checks. Cite sources by default.

05
Document Intelligence Agent
MED complexity

Reads PDFs, docs, images and extracts structured data. Upgrade: Combine vision + structured extraction with schema validation. Handle multi-page context carefully; chunk with overlap and reassemble.

06
Scientific Research Agent
HIGH complexity

Finds, synthesizes and cites scientific papers and data. Upgrade: Multi-source verification, citation integrity checks, and separation of primary vs secondary literature. Evaluation must include factual accuracy, not just fluency.

07
Tool-Using Agent
MED complexity

Uses APIs, code interpreters, browsers and CLIs to get work done. Upgrade: Prefer MCP for standardized tool discovery and calling. Implement schema validation, retries with backoff, and least-privilege scoping. Tool faults are a primary production failure mode.

08
Agentic Workflow System
HIGH complexity

Manages specialist sub-agents, tools and state to complete complex tasks. Upgrade: Hierarchical orchestrator preferred for debuggability. Shared state + structured handoffs. Checkpoint for durability. Multi-agent multiplies cost and failure surface — justify each addition.

Intelligence Agents 9–14

09
Data Analysis Agent

Cleans, analyzes and visualizes data; finds patterns and insights. Upgrade: Pair with verification agent. Use code execution sandboxes. Measure both statistical validity and business relevance.

10
Verification Agent

Verifies outputs, checks rules, constraints and catches errors. Upgrade: Critical for production. Implement as critic or evaluator-optimizer pattern. Cross-check facts, cite sources, flag low confidence. Essential against compounding errors.

11
Problem Solver

Tackles complex reasoning, multi-step problems and trade-offs. Upgrade: Explicit reasoning traces. Tree-of-thought or debate patterns when stakes are high. Always include exit criteria.

12
Code Generation Agent

Writes, refactors and tests code with best practices and docs. Upgrade: Test-driven loops, sandbox execution, security scanning. Strong coding models (e.g. Claude) preferred. Human review for production commits.

13
Security-Hardened Agent

Audits code, configs, prompts and flags vulnerabilities. Upgrade: Least privilege, input validation, prompt injection defenses, credential vaulting. Security must be designed in, not bolted on.

14
Self-Improving Agent

Learns from results, feedback and metrics. Improves over time. Upgrade: Controlled loops with evaluation gates. Do not allow unconstrained self-modification. Prefer offline evaluation and human-approved updates.

Multimodal Agents 15–20

15
Conversational Agent

Natural dialogue with state tracking and context awareness. Upgrade: Session memory + persona consistency. Escalation paths for sensitive topics. Measure conversation success beyond sentiment.

16
Content Creation Agent

Writes docs, blogs, reports, marketing copy and more. Upgrade: Brand voice constraints, fact-checking step, human editorial review for external content. Track originality and citation hygiene.

17
Recommendation Agent

Personalized suggestions from history, context and preferences. Upgrade: Transparency on why something is recommended. Consent for preference data. Avoid filter bubbles without user control.

18
Vision-Language Agent

Understands images, charts and diagrams; answers visual questions. Upgrade: Combine with document extraction. Ground visual claims in structured data where possible. Handle uncertainty explicitly.

19
Audio Processing Agent

Transcribes, summarizes and analyzes audio and video. Upgrade: Speaker diarization, confidence scoring on transcripts, privacy controls for recorded content.

20
Physical Sensing Agent

Analyzes IoT/sensor data, detects anomalies and predicts outcomes. Upgrade: Real-time constraints, safety interlocks for physical systems, clear human override paths.

Specialized, Domain & Integration Agents 21–30

21
Ethical Reasoning Agent

Evaluates fairness, bias, risk and aligns actions with values. Upgrade: Explicit value frameworks, bias detection metrics, and human escalation. Ethics is not a post-hoc check.

22
Explainable Agent

Explains decisions and reasoning in plain language. Upgrade: Faithful explanations tied to actual traces, not post-hoc rationalizations. Required for regulated domains.

23
Healthcare Intelligence Agent

Clinical notes, prior auth, insights and support for care teams. Upgrade: Strict privacy (PII/PHI), regulatory compliance (e.g. HIPAA-equivalent), and mandatory human review for clinical decisions.

24
Scientific Discovery Agent

Generates hypotheses, runs virtual experiments, finds insights. Upgrade: Hypothesis ranking with evidence strength. Separate generation from validation. Reproducibility requirements.

25
Financial Advisory Agent

Market analysis, risk models, forecasts and portfolio insights. Upgrade: Disclaimer discipline, regulatory boundaries, and audit trails. Never present as personalized advice without licensing.

26
Legal Intelligence Agent

Reviews contracts, summarizes clauses, flags risks and suggests actions. Upgrade: Jurisdiction awareness, citation to primary sources, and human attorney review for binding work.

27
Education Intelligence Agent

Creates lessons, quizzes, feedback and personalized learning paths. Upgrade: Pedagogical soundness checks, adaptive difficulty with fairness constraints, and teacher-in-the-loop options.

28
Collective Intelligence Agent

Aggregates multiple agents and sources for stronger answers. Upgrade: Structured aggregation (voting, debate, weighted consensus). Detect and mitigate groupthink or correlated errors.

29
Embodied Intelligence Agent

Works with robots, devices and systems; native physical actions. Upgrade: Safety layers, simulation-before-real, and hard kill switches. Physical world adds irreversible risk.

30
Domain-Transforming Agent

Leads organizational change with data, feedback loops and strategy. Upgrade: Change management discipline, measurable outcomes, and human leadership ownership. Technology enables; people decide.

DASH Framework 2.0 — Use This Template for Every Agent

WHAT TO DEFINE

  • WHAT — The agent's role, goal and scope.
  • WHAT — The failure mode it prevents.
  • WHAT — The builder and end user.
  • VERIFY — Success criteria and evaluation method.

WHEN & WHERE

  • WHEN — The trigger or state.
  • WHERE — The position in the architecture.
  • HOW — The inputs, structure and tools.
  • STOP — Explicit exit conditions and budgets.

PROMPT MUST-HAVES

  • TASK — What to do.
  • PROTOCOL — How to act.
  • CONSTRAINTS — What not to do.
  • STOP — When to stop.
  • CITE — Source requirements.

DESIGN PRINCIPLES

  • Own responsibility.
  • Verify before act.
  • Specialist over generalist.
  • Build for iteration.
  • Layer & isolate.
  • Least privilege.

The Non-Negotiable Rules

RULE — WHY IT MATTERS

  • Define stopping conditions → Agents without exit criteria loop indefinitely.
  • Build the “no result” path → No path = confident hallucination at scale.
  • Write memory, not just read → Most stay brittle without long-term memory.
  • Pass full context to specialists → They share no memory with coordinator.
  • Always include a verification agent → No agent reliably grades its own output.
  • Instrument every handoff → Silent failures are the hardest to debug.

COMMON FAILURES (FIELD-VALIDATED)

  • No stopping conditions → infinite loops
  • No “no result” path → wrong confidence
  • Memory writes skipped → context loss
  • Assumed context → hidden bugs
  • Tool faults (~60% task-completion drop in studies)
  • Compounding errors on multi-step tasks
  • Missing observability / “distrust tax”
Build Order: 1st Foundation (01–08) → 2nd Intelligence (09–14) → 3rd Multimodal (15–20) → 4th Specialized (21–24) → 5th Domain (25–27) → 6th Integration (28–30). Start with the smallest pattern that solves the problem.

Implementation Code Patterns

Production-oriented starter patterns. Prefer explicit state graphs, hard budgets, verification nodes, and least-privilege tools. Examples use Python with LangGraph-style structure (adaptable to other frameworks). All include stopping conditions and basic observability hooks.

01 · Autonomous Decision Agent — Bounded Loop with Budget

Minimal ReAct-style loop with explicit turn budget and structured exit.

from typing import TypedDict, Literal
from langgraph.graph import StateGraph, END

class DecisionState(TypedDict):
    goal: str
    history: list
    decision: str | None
    turns: int
    max_turns: int
    done: bool

def decide(state: DecisionState) -> DecisionState:
    if state["turns"] >= state["max_turns"]:
        state["decision"] = "MAX_TURNS_REACHED — escalate to human"
        state["done"] = True
        return state
    # Call model here with structured output schema
    # result = model.invoke(...)
    # state["decision"] = result.decision
    # state["done"] = result.confidence > 0.8 and result.actionable
    state["turns"] += 1
    return state

def should_continue(state: DecisionState) -> Literal["decide", END]:
    return END if state["done"] else "decide"

graph = StateGraph(DecisionState)
graph.add_node("decide", decide)
graph.set_entry_point("decide")
graph.add_conditional_edges("decide", should_continue)
app = graph.compile()
# Always set max_turns (e.g. 8) and log every transition
02 · Planning Agent — Hierarchical Decomposition

Planner produces a validated plan, then executor steps through it with checkpoints.

class PlanState(TypedDict):
    goal: str
    plan: list[dict]   # [{step, owner, success_criteria, status}]
    current_step: int
    result: str | None

def plan(state: PlanState) -> PlanState:
    # Model call with strict JSON schema for plan
    # Validate: max 6 steps, each has success_criteria
    state["plan"] = validated_plan
    state["current_step"] = 0
    return state

def execute_step(state: PlanState) -> PlanState:
    step = state["plan"][state["current_step"]]
    # Run specialist or tool for this step
    step["status"] = "completed"  # or "failed" → trigger replan
    state["current_step"] += 1
    return state

def route(state: PlanState) -> Literal["execute", "replan", END]:
    if state["current_step"] >= len(state["plan"]):
        return END
    if state["plan"][state["current_step"]].get("status") == "failed":
        return "replan"
    return "execute"

# graph.add_node("plan", plan)
# graph.add_node("execute", execute_step)
# graph.add_conditional_edges("execute", route)
03 · Memory-Augmented Agent — Layered Memory

Working context + episodic log + selective semantic retrieval. Always write and expire.

class MemoryState(TypedDict):
    working: list          # current turn messages (truncated)
    episodic: list         # past session summaries (timestamped)
    retrieved: list        # vector hits for this query
    last_write: str | None

def retrieve(state: MemoryState) -> MemoryState:
    # query = embed(state["goal"])
    # state["retrieved"] = vector_store.similarity_search(query, k=4)
    return state

def update_memory(state: MemoryState) -> MemoryState:
    summary = summarize(state["working"][-6:])  # keep short
    state["episodic"].append({"ts": now(), "summary": summary})
    # Expire old entries > 30 days or low relevance
    state["last_write"] = summary
    return state

# Always call update_memory before ending a run.
# Prefer summary writes over full transcript dumps.
07 · Tool-Using Agent — MCP-Style + Validation

Typed tools, schema validation, retries, and least privilege.

from pydantic import BaseModel

class SearchArgs(BaseModel):
    query: str
    max_results: int = 5

def search_tool(args: SearchArgs) -> dict:
    # Call actual search / MCP server
    results = mcp_search(args.query, limit=args.max_results)
    return {"results": results, "source": "web"}

tools = {
    "search": {"schema": SearchArgs, "fn": search_tool, "permission": "read"},
    # Never give write tools without explicit human gate
}

def call_tool(state: dict) -> dict:
    name = state["tool_call"]["name"]
    raw = state["tool_call"]["args"]
    schema = tools[name]["schema"]
    try:
        validated = schema(**raw)
        result = tools[name]["fn"](validated)
        state["tool_result"] = result
    except Exception as e:
        state["tool_result"] = {"error": str(e), "retryable": True}
    return state

# Bind only the tools the current role is allowed to use.
08 · Agentic Workflow — Hierarchical Orchestrator

Supervisor + specialists. Structured handoffs, shared state, checkpoints.

class WorkflowState(TypedDict):
    task: str
    plan: list
    specialist_results: dict
    final: str | None
    budget_remaining: int

def supervisor(state: WorkflowState) -> WorkflowState:
    # Decide next specialist or finish
    # Always decrement budget_remaining
    if state["budget_remaining"] <= 0:
        state["final"] = "BUDGET_EXHAUSTED — human review required"
        return state
    return state

def specialist_research(state: WorkflowState) -> WorkflowState:
    # Isolated context + tools for research only
    state["specialist_results"]["research"] = result
    return state

# graph.add_node("supervisor", supervisor)
# graph.add_node("research", specialist_research)
# graph.add_conditional_edges("supervisor", route_to_specialist_or_end)
# Compile with checkpointer=MemorySaver() or Postgres for durability
10 · Verification Agent — Independent Critic

Never let an agent grade its own output. Separate critic node.

class VerifyState(TypedDict):
    claim: str
    evidence: list
    verdict: Literal["pass", "fail", "uncertain"]
    issues: list
    confidence: float

def critic(state: VerifyState) -> VerifyState:
    # Different prompt / model if possible
    # Check: citations present, constraints satisfied, no contradictions
    # state["verdict"] = "fail" if missing_citations or low_confidence
    # state["issues"] = ["No primary source", "Exceeds risk threshold"]
    return state

def gate(state: VerifyState) -> Literal["retry", "escalate", END]:
    if state["verdict"] == "pass" and state["confidence"] > 0.85:
        return END
    if state["verdict"] == "uncertain":
        return "escalate"   # human-in-the-loop
    return "retry"

# Place verification before any consequential action or external output.
Production Checklist for Any Pattern: Explicit state schema · Hard turn/token/cost budget · Structured handoffs · Independent verification node · Checkpointing · Least-privilege tool binding · Observability (trace every node) · Human interrupt path for high-stakes decisions.

Research & Field Foundations

This upgrade draws on:

ImageFirm publishes working documents in the open. This reference continues that practice: transparent, practical, and human-centered.