codeYaan Logo Blog
Home Blog Services Courses
Login
Agentic AI: What It Is and How to Build One
HOW TO GUIDES Dec. 23, 2025, 11:30 p.m.

Agentic AI: What It Is and How to Build One

Imagine a software agent that doesn’t just follow a script, but decides *what* to do next based on goals, context, and feedback. That’s the promise of agentic AI—systems that act autonomously, plan, and adapt without human micromanagement. In this article we’ll demystify the concept, explore the building blocks, and walk through two end‑to‑end examples you can run on your laptop today.

What Is Agentic AI?

Agentic AI refers to intelligent agents that possess a sense of agency: they can set sub‑goals, choose actions, and evaluate outcomes to achieve a higher‑level objective. Unlike classic chatbots that react to a single prompt, an agentic system maintains state, can call external APIs, and iteratively refine its plan until the goal is satisfied.

Key ingredients include a goal representation, a planning module, a perception loop (often powered by LLMs), and an execution environment. The agent’s “brain” may be a large language model, a reinforcement‑learning policy, or a hybrid of both. The result is a system that behaves more like a helpful colleague than a scripted tool.

Core Concepts

Goal Specification

Every agent starts with a clear, machine‑readable goal. This can be a natural‑language instruction (e.g., “Summarize the latest earnings report”) or a structured JSON schema that defines success criteria. The goal is the anchor that guides planning and evaluation.

Planning and Reasoning

Planning is the process of breaking a goal into actionable steps. Modern agents often use LLMs with chain‑of‑thought prompting to generate a plan, then verify it against constraints. Some systems incorporate classic planning algorithms (like A* or STRIPS) for deterministic tasks.

Perception and Action Loop

Agents continuously perceive their environment—reading files, calling APIs, or parsing web pages—and then decide on the next action. This loop repeats until the goal state is reached or a timeout occurs. The loop is typically orchestrated by a controller function that feeds observations back into the LLM.

Memory and State Management

To avoid re‑solving the same sub‑problem, agents store intermediate results in short‑term or long‑term memory. Simple implementations use Python dictionaries; more sophisticated agents rely on vector stores (e.g., FAISS) to retrieve relevant past experiences.

Building Blocks You Need

  • LLM Backend: OpenAI’s gpt‑4o, Anthropic Claude, or any locally hosted model.
  • Tooling Layer: Functions that wrap external services (web scraping, database queries, file I/O).
  • Orchestrator: A loop that sends prompts, parses responses, and dispatches tool calls.
  • Memory Store: In‑memory dicts for prototypes; Redis or a vector DB for production.
  • Safety Guardrails: Prompt filters, token limits, and sandboxed execution environments.

With these pieces in place, you can start assembling a functional agent. Below we’ll build two concrete examples: a personal meeting‑assistant and an autonomous data‑cleaner.

Example 1: Autonomous Meeting Assistant

This agent reads a user’s calendar, identifies free slots, drafts a meeting invitation, and sends it via email—all without further input. The workflow demonstrates goal‑driven planning, external API calls, and state persistence.

Step‑by‑Step Implementation

import os, json, datetime, smtplib
from email.message import EmailMessage
import openai  # pip install openai

# -------------------------------------------------
# 1️⃣  Configuration
# -------------------------------------------------
openai.api_key = os.getenv("OPENAI_API_KEY")
SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT = 587
SMTP_USER = os.getenv("SMTP_USER")
SMTP_PASS = os.getenv("SMTP_PASS")

# -------------------------------------------------
# 2️⃣  Helper functions (tools)
# -------------------------------------------------
def get_calendar_events(date: str) -> list:
    """
    Mock function – in a real system you would call Google Calendar API.
    Returns a list of busy time ranges for the given date.
    """
    # Example busy slots
    return [("09:00", "10:30"), ("13:00", "14:00")]

def send_email(to: str, subject: str, body: str) -> None:
    msg = EmailMessage()
    msg["From"] = SMTP_USER
    msg["To"] = to
    msg["Subject"] = subject
    msg.set_content(body)
    with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as s:
        s.starttls()
        s.login(SMTP_USER, SMTP_PASS)
        s.send_message(msg)

# -------------------------------------------------
# 3️⃣  Agent core – planning & execution loop
# -------------------------------------------------
def meeting_assistant(goal: str) -> None:
    """
    Goal example: "Schedule a 30‑minute sync with Alice next week."
    """
    # 1️⃣  Prompt LLM to create a plan
    plan_prompt = f\"\"\"
You are an autonomous meeting assistant. Your goal is: {goal}
Create a concise step‑by‑step plan in JSON format.
Each step must contain:
- "action": name of the tool to call (e.g., get_calendar_events, send_email)
- "args": dictionary of arguments for the tool
- "reason": short justification
\"\"\"
    response = openai.ChatCompletion.create(
        model="gpt-4o",
        messages=[{"role":"system","content":"You are a planning AI."},
                  {"role":"user","content":plan_prompt}],
        temperature=0
    )
    plan = json.loads(response.choices[0].message.content)

    # 2️⃣  Execute the plan
    state = {}
    for step in plan:
        action = step["action"]
        args = step["args"]
        if action == "get_calendar_events":
            date = args["date"]
            state["busy"] = get_calendar_events(date)
        elif action == "send_email":
            send_email(**args)
        else:
            raise ValueError(f"Unknown action {action}")

# -------------------------------------------------
# 4️⃣  Run the agent
# -------------------------------------------------
if __name__ == "__main__":
    meeting_assistant(
        "Schedule a 30‑minute sync with Alice on Thursday next week and email her the invite."
    )

The LLM generates a JSON plan that might look like:

[
  {"action":"get_calendar_events","args":{"date":"2025-01-03"},"reason":"Check my availability on Thursday."},
  {"action":"send_email","args":{"to":"alice@example.com","subject":"Meeting Invite","body":"..."},"reason":"Send the finalized invitation."}
]

Because the plan is explicit, you can audit each step before execution—a crucial safety feature for any autonomous system.

Pro tip: Always keep the LLM’s temperature low (0‑0.2) when generating actionable JSON. This reduces hallucinations and ensures deterministic tool calls.

Example 2: Self‑Cleaning Data Pipeline

Data scientists spend hours cleaning CSVs, handling missing values, and normalizing formats. An agentic AI can take a raw file, infer the schema, apply appropriate transformations, and output a clean dataset ready for modeling.

Implementation Overview

  • Goal: “Clean sales_raw.csv so that all numeric columns are cast to float, dates to ISO format, and missing values are imputed with the column median.”
  • Tools: Pandas for manipulation, OpenAI for schema inference, and a simple memory cache for previously seen column types.
import pandas as pd, numpy as np, json, os, openai

openai.api_key = os.getenv("OPENAI_API_KEY")

# -------------------------------------------------
# 1️⃣  Tool: infer_schema
# -------------------------------------------------
def infer_schema(df: pd.DataFrame) -> dict:
    """
    Ask the LLM to classify each column as 'numeric', 'date', or 'categorical'.
    Returns a dict: {column_name: type}
    """
    sample = df.head(5).to_csv(index=False)
    prompt = f\"\"\"
You are given a CSV snippet. Identify the data type of each column.
Return a JSON object where keys are column names and values are one of:
'numeric', 'date', 'categorical'.
CSV snippet:
{sample}
\"\"\"
    resp = openai.ChatCompletion.create(
        model="gpt-4o-mini",
        messages=[{"role":"user","content":prompt}],
        temperature=0
    )
    return json.loads(resp.choices[0].message.content)

# -------------------------------------------------
# 2️⃣  Tool: clean_dataframe
# -------------------------------------------------
def clean_dataframe(df: pd.DataFrame, schema: dict) -> pd.DataFrame:
    for col, typ in schema.items():
        if typ == "numeric":
            df[col] = pd.to_numeric(df[col], errors="coerce")
            median = df[col].median()
            df[col].fillna(median, inplace=True)
        elif typ == "date":
            df[col] = pd.to_datetime(df[col], errors="coerce")
            df[col] = df[col].dt.strftime("%Y-%m-%d")
            df[col].fillna(method="ffill", inplace=True)
        else:  # categorical
            df[col] = df[col].astype("category")
            df[col].fillna("Unknown", inplace=True)
    return df

# -------------------------------------------------
# 3️⃣  Agent orchestration
# -------------------------------------------------
def autonomous_cleaner(input_path: str, output_path: str) -> None:
    raw = pd.read_csv(input_path)
    schema = infer_schema(raw)
    clean = clean_dataframe(raw, schema)
    clean.to_csv(output_path, index=False)
    print(f"✅ Cleaned data saved to {output_path}")

# -------------------------------------------------
# 4️⃣  Execute
# -------------------------------------------------
if __name__ == "__main__":
    autonomous_cleaner("sales_raw.csv", "sales_clean.csv")

Notice how the LLM is only used for schema inference—a task that is notoriously error‑prone for pure regex solutions. The rest of the pipeline remains deterministic and fully testable.

Pro tip: Cache the schema results (e.g., in a JSON file) so the agent doesn’t repeatedly query the LLM for the same dataset, saving both cost and latency.

Real‑World Use Cases

Agentic AI is already reshaping industries. In customer support, agents triage tickets, draft replies, and trigger refunds without human oversight, reducing average handling time by up to 40 %.

In robotics, autonomous warehouse bots plan pick‑and‑place routes on the fly, reacting to obstacles and inventory changes. Their planning loop mirrors the LLM‑driven approach we showcased, only the “action” layer swaps HTTP calls for motor commands.

Financial institutions employ agents to monitor transaction streams, flag anomalies, and generate compliance reports. The agents combine rule‑based alerts with LLM‑generated narratives, delivering both speed and explainability.

Challenges & Ethical Considerations

While the technology is exciting, it brings new responsibilities. Hallucinated plans, unbounded API calls, and privacy leaks are real risks. Always sandbox tool execution, enforce rate limits, and log every LLM‑generated decision for auditability.

Another challenge is alignment: agents must respect user intent even when the goal is ambiguous. Prompt engineering, reinforcement‑learning from human feedback (RLHF), and explicit constraint checking are common mitigation strategies.

Finally, consider the impact on jobs. Agentic systems can augment workers, but they can also automate tasks traditionally performed by humans. Transparent communication and upskilling programs help mitigate displacement concerns.

Best Practices for Building Robust Agents

  • Deterministic Planning: Keep LLM temperature low when generating actionable JSON.
  • Explicit Schemas: Define input and output contracts for every tool.
  • Fail‑Safe Loops: Include a maximum iteration count and a “fallback” path if the agent gets stuck.
  • Observability: Log prompts, responses, and tool outcomes to a centralized dashboard.
  • Security First: Run tool calls in isolated containers; never expose raw LLM output to the OS directly.
Pro tip: Wrap each tool in a thin validation layer that checks argument types and sanitizes strings before they hit the external service. This eliminates a whole class of injection attacks.

Conclusion

Agentic AI elevates language models from passive responders to proactive problem‑solvers. By pairing LLM reasoning with well‑defined tools, memory, and safety checks, you can create systems that plan, act, and learn in real time. The two examples above—an autonomous meeting assistant and a self‑cleaning data pipeline—illustrate how a few hundred lines of Python can deliver genuine agency.

As the field matures, expect richer planning primitives, tighter integration with reinforcement learning, and broader adoption across enterprises. Start small, iterate fast, and always keep the human in the loop. With those principles, you’ll be well‑positioned to harness the next wave of intelligent automation.

Share this article
Back to Blog