AI Agents 101: Tools, Memory, and Planning

Introduction

AI agents are systems that decide what to do next, call tools, remember context, and plan multi step tasks toward a goal. For learners at Cinute Digital Pvt Ltd (CDPL) and partner teams, this guide explains core concepts with code patterns you can run, plus safety and evaluation so agents help rather than hinder production work.

What Is an AI Agent

An AI agent is a loop: observe state, reason about options, act with a tool, and update memory before repeating. Unlike a single prompt, agents chain steps and learn from context. A practical agent needs three pillars: tools to take actions, memory to keep relevant facts, and planning to choose the next step.

Agent Architecture at a Glance

• Inputs: user goal, environment state, policies and constraints.
• Reasoning: selection of next action using prompts, search, or rules.
• Tools: functions for search, database, code execution, email, or business APIs.
• Memory: short term scratchpad, long term vector store, and episodic logs.
• Planner: strategies like ReAct, task decomposition, or graph based workflows.
• Evaluator: quality, cost, latency, and safety checks with fallbacks.

Tools and Function Calling

Tools turn thoughts into actions. Define a clear schema and let the model pick a function and arguments. Keep tools idempotent and observable.

# Minimal function calling style example
import json

TOOLS = {
  "search_web": {"description": "Search the web", "args": {"query": "string"}},
  "get_weather": {"description": "Weather by city", "args": {"city": "string"}}
}

def call_tool(name, args):
  if name == "search_web":
    return f"Top result for {args['query']}"
  if name == "get_weather":
    return f"{args['city']}: 28C and clear"
  return "Unknown tool"

def agent_step(state, llm):
  # state contains messages and scratchpad
  tool_suggestion = llm.pick_tool(TOOLS, state)  # pseudo API
  result = call_tool(tool_suggestion["name"], tool_suggestion["args"])
  state["scratchpad"].append({"tool": tool_suggestion["name"], "result": result})
  return state

Give tools strong names, concise descriptions, and strict argument schemas

Memory: Short Term and Long Term

Short term memory lives in the conversation or scratchpad for the current task. Long term memory stores reusable knowledge in a vector database for retrieval augmented generation.

• Short term: chain of thought summary, last tool results, current plan.
• Long term: docs, SOPs, past tickets, user preferences, and embeddings.

# Simple vector memory with FAISS like pattern (pseudo)
from sklearn.feature_extraction.text import TfidfVectorizer
import numpy as np

docs = ["Refund policy v3", "SLA for enterprise", "How to export reports"]
V = TfidfVectorizer().fit_transform(docs)

def retrieve(q, k=2):
  qv = TfidfVectorizer().fit(docs).transform([q])  # demo only
  scores = (V @ qv.T).toarray().ravel()
  idx = np.argsort(scores)[::-1][:k]
  return [docs[i] for i in idx]

In production use a real embedding model and FAISS, Milvus, or a managed vector DB

Planning Strategies That Work

ReAct planning

Alternate between reasoning and action. The agent thinks, selects a tool, observes results, and iterates until done.

Task decomposition

Break a large goal into smaller subtasks with milestones and owners. Great for workflows like data pipelines or content production.

Routing and graphs

Use decision nodes to route to specialized tools or sub agents. Useful when you have different skills like search, math, and database access.

User goal: "Create a weekly sales summary for India and UAE"

Plan:
1) Retrieve last 7 days of orders
2) Aggregate by country and product
3) Generate chart and draft email
4) Ask for confirmation before sending

Keep plans explicit and auditable for users and reviewers

RAG for Agents

Retrieval Augmented Generation grounds the agent in your knowledge. Retrieve the top passages per step and show citations. Cache frequent lookups to reduce cost and latency.

• Chunk size tuned for your doc types
• Hybrid search with dense and keyword
• Citations and confidence in every answer

Guardrails and Safety

• Input filters: PII detection, allowlists for domains and tools.
• Output checks: toxicity, hallucination risk, and red team prompts.
• Tool policies: rate limits, dry run mode, and human approval for high risk actions.
• Observability: logs, traces, metrics, and cost dashboards.

Evaluate Agents Like a Product

Use a benchmark of tasks and hidden test cases. Track success rate, steps to completion, cost, latency, and user ratings.

# Tiny evaluator sketch
tests = [
  {"goal": "Summarize refund policy", "oracle": "mentions window and method"},
  {"goal": "Draft weekly sales email", "oracle": "has totals and countries"}
]

def evaluate(agent, tests):
  scores = []
  for t in tests:
    out = agent.run(t["goal"])
    ok = all(kw in out.lower() for kw in t["oracle"].split())
    scores.append(int(ok))
  return sum(scores) / len(scores)

Start simple, then add human review and rubrics per use case

Real World Patterns

• Support copilot: retrieve policy, summarize conversation, and propose replies with citations.
• Data analyst agent: query warehouse, explain metrics, and generate charts with approval.
• QA workflow agent: run tests, open issues with evidence, and post results to a channel.

Quick Start Checklist for CDPL Learners

1. Pick one narrow use case with clear success criteria.
2. Define 3 to 5 safe tools with strict schemas.
3. Add short term scratchpad and a small vector memory.
4. Start with ReAct planning and visible step by step logs.
5. Ship behind a flag, collect feedback, and iterate weekly.

Conclusion

AI agents are most effective when tools are well designed, memory is relevant and concise, and planning is transparent. Start with a small workflow, add guardrails and evaluation, and iterate in public with your team. With this approach, CDPL learners and partner teams can ship agents that are useful, reliable, and safe.