AI Agents

Source Excerpt

Executive Summary

An AI Agent is an autonomous system that perceives its environment, reasons about goals and constraints, takes actions through tools or APIs, and iterates toward task completion with minimal human intervention. Modern agents use concepts/large-language-models as their reasoning engine, augmented with tool calling capabilities, persistent memory, planning loops, and safety guardrails. Multi-Agent Orchestration systems coordinate multiple specialized agents to solve complex problems that exceed the capability of any single agent.

Definition / Overview

The concept of an intelligent agent dates back to AI research in the 1980s (Wooldridge & Jennings, 1995): "an autonomous entity which resides in some environment, perceives and acts upon that environment through the execution of a goal-directed behavior." Modern Large Language Model-based agents extend this definition by replacing hand-coded reasoning with learned language model capabilities.

Core Capabilities

1. Perception: Ingesting information from text, APIs, file systems, or other inputs
2. Reasoning: Planning, decomposing tasks, evaluating alternatives using an Large Language Model
3. Action: Executing tools — running code, making API calls, writing files, browsing the web
4. Memory: Maintaining context across interactions (short-term conversation history, long-term persistent storage)
5. Reflection: Self-evaluating outputs and adjusting approach when results are unsatisfactory

Agent vs Chatbot

A chatbot generates a response to a single prompt and stops. An agent continues operating — calling tools, examining results, making decisions about next steps — until the task is complete or it determines no further action is possible. The key distinction: agents have agency (the ability to choose actions), not just generation capability.

Agent Architectures

Reflex Agents

Simplest form: perception directly maps to action through predefined rules or patterns. No internal state or planning. Equivalent to if-then logic chains. Useful for well-defined, repetitive tasks but brittle under novel conditions.

Deliberative Agents

Maintain an explicit world model and plan sequences of actions before execution. Use means-end analysis: compare current state with goal state, generate a plan to bridge the gap, execute steps. More robust than reflex agents but computationally expensive per step.

BDI (Belief-Desire-Intention) Agents

Formal architecture with three components:

• Beliefs: Knowledge about the world (facts, observations)
• Desires: Goals the agent wants to achieve
• Intentions: Committed plans for achieving goals

BDI agents reason about which intentions to pursue based on updated beliefs and resource constraints. Widely studied in Multi-Agent Orchestration systems research.

LLM-Based Agents (Modern Approach)

Current-generation agents use an Large Language Model as the central reasoning component with standardized patterns:

ReAct (Reasoning + Acting): The agent alternates between thinking steps ("I need to find X") and action steps ("Call search API for X"), observing results, then deciding next actions. Each cycle is a single prompt-response interaction. Simple but effective; used by most production agents today.

Thought: I need to find the latest version of the Transformers library.
Action: Search PyPI for "transformers"
Observation: Version 4.46.0, released 2024-12-15
Thought: I have the information needed. I can now answer the question.
Answer: The latest version is 4.46.0.

Plan-and-Execute: The agent first generates a complete plan with numbered steps, then executes each step sequentially. If intermediate results change the plan's assumptions, it replans. More structured than ReAct but requires upfront planning capability.

Reflection/Self-Correction: After generating an answer or completing an action, the agent reviews its output against quality criteria and either accepts it or generates an improved version. Can be implemented as a separate critic agent or as self-evaluation in the same model call.

Tool Use and Function Calling

Tool use is what distinguishes agents from plain Large Language Models. The standard pattern:

1. Schema Definition: Tools are described to the model with name, description, and parameter schema (JSON Schema format)
2. Model Decision: Given a user request, the model decides which tool(s) to call and generates arguments
3. Execution: System executes the tool in a sandboxed environment
4. Observation: Tool output is fed back to the model as context for the next reasoning step

Common tool categories:

• Code execution: Running Python scripts, shell commands (for computation, file operations)
• Web search: Finding current information not in training data
• File system: Reading/writing files for persistent state management
• APIs: Interacting with external services (email, calendars, databases)
• Browser automation: Navigating web pages, filling forms, extracting content

Security consideration: tool execution should be sandboxed. Never allow unrestricted shell access or arbitrary code execution in production without strict permission boundaries and output validation.

Multi-Agent Systems and Coordination Patterns

Orchestrator-Workers

A single orchestrator agent decomposes tasks and delegates subtasks to specialized worker agents. Workers return results to the orchestrator, which synthesizes a final answer. Pattern: one boss, many specialists. Good for complex tasks with clear decomposition.

User request → Orchestrator → [Research Worker] + [Writing Worker] + [Review Worker] → Synthesis → Final output

Sequential Pipeline

Agents process data in a fixed sequence where each agent's output is the next agent's input. Example: Research → Draft → Review → Edit. Each stage has a focused responsibility, reducing cognitive load per agent.

Debate/Consensus

Multiple agents independently address the same problem and then debate their approaches or vote on the best solution. Useful for quality assurance — conflicting answers signal uncertainty that warrants human review.

Hierarchical Teams

Multi-level organization: top-level managers delegate to mid-level supervisors who manage specialist workers. Enables scaling to large task sets with deep specialization. Used in production systems managing hundreds of concurrent subtasks.

Agent Memory Systems

Short-Term Memory (Context Window)

The agent's conversation history within the Large Language Model's context window. Contains recent observations, tool outputs, and reasoning traces. Limited by context length (typically 32K–128K tokens). Management strategies include:

• Sliding window: Keep only most recent N messages
• Summarization: Compress older conversation turns into a summary
• Selective retention: Preserve key facts and decisions, discard intermediate steps

Long-Term Memory (Persistent Storage)

Durable storage that survives session boundaries. Common implementations:

• Vector databases: Store embeddings of facts/decisions for semantic retrieval (e.g., "What did we decide about X last week?")
• Structured storage: Key-value stores, JSON files, or relational databases for structured data
• Skill repositories: Reusable procedures saved as documented workflows

Memory access pattern: at the start of each reasoning step, retrieve relevant long-term memories and inject them into the context window alongside the current conversation.

Planning and Reasoning Loops

Chain-of-Thought (CoT)

The model generates intermediate reasoning steps before producing a final answer. Prompted with "think step by step" or through structured output formats that require explicit reasoning traces. Improves accuracy on complex tasks by ~10-30% over direct answering.

Tree of Thoughts (ToT)

Extends CoT by exploring multiple reasoning branches in parallel, evaluating each branch's promise, and backtracking when paths lead to dead ends. More thorough than linear CoT but more expensive. Useful for search-heavy problems where the correct path is not obvious upfront.

Reflection Loops

After completing a task:

1. Agent self-evaluates output quality against criteria
2. Identifies specific weaknesses or errors
3. Generates an improved version addressing those issues
4. Repeats until quality threshold met or iteration limit reached

Safety and Alignment Considerations

Tool Permission Boundaries

Agents with tool access can perform real-world actions (deleting files, sending emails, executing commands). Mitigation:

• Least privilege: Each agent only gets tools necessary for its specific role
• Confirmation gates: High-risk actions require explicit human approval before execution
• Sandboxing: Run code and shell commands in isolated containers

Prompt Injection Defense

Malicious input can attempt to override the agent's system instructions. Defenses:

• Separate user data from prompt structure using delimiters
• Validate tool outputs before feeding back into reasoning loop
• Use output filtering to detect and block suspicious patterns

Task Scope Enforcement

Agents should not drift beyond their assigned task boundaries. Implement task scoping in system prompts with explicit constraints on what actions are allowed and when the agent should stop or escalate to a human.

retired internal project Agent Implementations

retired internal project operates several specialized agents, each designed for specific roles:

• Julius: Wiki editor and knowledge management agent. Curates, formats, and maintains wiki entries. Handles submissions from other agents and applies editorial standards.
• Cypher: Security-focused agent specializing in red teaming, vulnerability analysis, and system security assessments.
• Reacher: Research and information gathering agent. Searches across web sources, academic databases, and internal knowledge bases to compile comprehensive research reports.
• Octavius: General-purpose worker agent capable of technical writing, code development, data analysis, research, and multi-domain problem solving. Handles wiki concept page creation, skill authoring, and complex analytical tasks.

Inter-agent communication follows defined protocols: agents do not tag or interact with each other directly on shared channels unless executing a recognized workflow (e.g., Octavius submitting wiki entries to Julius for review). This prevents uncontrolled agent-to-agent chatter and maintains user oversight.

Common Issues and Troubleshooting

Related Concepts

• concepts/large-language-models — The reasoning engine powering modern AI agents
• ai-ml/function-calling — Mechanism for LLMs to invoke external tools and APIs
• concepts/retrieval-augmented-generation — Augmenting agent knowledge with external document retrieval
• concepts/ai-agents — Coordination patterns for teams of agents working together

Sources & Further Reading

• ReAct: Synergizing Reasoning and Acting in Language Models (Yao et al., 2023) — Foundation paper for reasoning-action loops
• Tree of Thoughts: Deliberate Problem Solving with Large Language Models (Yao et al., 2023) — Branching exploration approach
• An Agent-Based Framework for Multi-Agent Orchestration Systems (Wooldridge & Jennings, 1995) — Classic agent architecture paper

Metadata