Overview of Agentic AI

The key components of agent systems include:

• Planning: Breaking down complex tasks into executable subtasks.
• Tool Usage: Interacting with the external world via function calls or code generation to fetch real-time information or perform computations.
• Reflection: The model’s ability to self-assess and critically revise its intermediate outputs to improve the final result.
• Multi-Agent Collaboration: Assigning different agents with specific roles to handle different subtasks.

The main advantage of this agent paradigm is that it enables language models to solve complex problems beyond the scope of a single prompt–response interaction. By combining retrieval-augmented generation (RAG), iterative calls, and external tools, agent systems effectively overcome the limitations of traditional language models, such as knowledge cutoffs, hallucinations, and lack of domain expertise. To successfully build and apply Agentic AI, one must master solid prompt-engineering best practices and establish a robust automated evaluation system—both are crucial for system iteration and optimization.

Foundations of Language Models (LMs)

Core Definition and Training

A language model (LM) is a machine learning model whose fundamental task is to predict the most likely next word given an input text. Its capabilities stem from a two-stage training process:

1. Pre-training: The model is trained on vast corpora of publicly available text (from the internet, books, etc.) to learn statistical patterns of language—essentially “next word prediction.” After this stage, the model has broad world knowledge and can generate fluent text.
2. Post-training: Pre-trained models are not directly usable. Post-training makes them more user-friendly and aligned with human preferences. This includes:
   • Instruction-Following Training: Fine-tuning the model with instruction–response datasets to make it understand and follow tasks.
   • Reinforcement Learning with Human Feedback (RLHF): Using human preference data to guide the model through a reward system, aligning outputs with human values and expectations.

Applications and Interaction

Well-trained LMs are widely used in daily work and life, such as:

• AI coding assistants
• Domain-specific AI co-pilots
• Conversational interfaces (e.g., ChatGPT)

Two main modes of interaction exist:

• Cloud API calls: Sending API requests to provider servers to get model outputs—common for application integration.
• Local hosting: Deploying smaller models locally on machines or mobile devices—suitable for low-resource scenarios.

Best Practices for Effective LM Use

Prompting is the key to guiding LMs toward desired outputs. Proven strategies include:

LM Limitations and Solutions

Limitations

Despite their power, LMs have inherent constraints:

• Hallucination: Generating plausible but false content.
• Knowledge cutoff: Limited to pre-training data up to a certain date.
• Lack of attribution: Cannot point to exact sources.
• Data privacy: Not trained on proprietary/secure datasets.
• Context length limits: Still bounded, with longer contexts raising cost and latency.

Solutions

Retrieval-Augmented Generation (RAG)

RAG integrates external knowledge bases with LMs:

• Process:
  1. Preprocess & index documents into chunks.
  2. Embed and store in a vector database.
  3. Retrieve top-K relevant chunks by similarity search.
  4. Inject them into the prompt for grounded answers.
• Benefits:
  • Reduces hallucination.
  • Provides attribution.
  • Uses private and up-to-date data.
  • Efficiently manages limited context.

Tool Usage and Function Calling

Allows LMs to interact with the world:

• Process:
  1. Generate structured function calls (e.g., get_weather('San Francisco')).
  2. Software executes real API calls.
  3. Results are fed back.
  4. LM produces a natural-language reply.
• Extension: Generate executable code in a sandbox for computations.

Introduction to Agentic AI

Agentic AI represents the systematized integration of these solutions, marking the advanced stage of LM use. Its core lies in combining reasoning and action.

Core Definition: Reasoning + Action

Agent systems are cycles of:

• Reasoning: Thinking/planning with CoT and other methods.
• Action: Executing via tools, APIs, code, or retrieval.

Agent Workflow

1. Plan: Break complex tasks into steps.
2. Act: Choose tools to execute each step (e.g., APIs).
3. Observe & Memorize: Process tool results and store memory.
4. Conclude: Synthesize results into final output.

Example: Customer Support AI Agent

• User: “Can I request a refund for product Foo?”
• Workflow:
  1. Plan: a) Check refund policy; b) Fetch order; c) Verify product; d) Decide.
  2. Act: a) Use RAG for policies; b) Call order API; c) Call product DB.
  3. Observe & Memorize: Integrate info.
  4. Conclude: Draft reply, possibly trigger refund API.

Agentic AI Design Patterns

Key Considerations

• Evaluation: Upgrade LM-as-a-Judge to agent-based review (e.g., senior engineer agent reviewing junior).
• Getting started: Begin with playground experiments → simple API calls → frameworks.
• Ethics & hallucination: Use guardrails (filters, classifiers) to block unsafe inputs/outputs.
• Fine-tuning data: Start with small datasets (dozens of samples), expand iteratively, and augment with synthetic data if needed.