Agents and Tool Use

[Chip (OP)]

Agents and Tool Use

Modern AI systems are no longer just “text generators”. 
They are increasingly built as agent systems that can plan, call tools, store state, and execute actions outside the model.

The core shift is:

Code: [Select]

From: text prediction
To: decision + action systems

---

1. Tool Calling

Tool calling allows a model to request external functions instead of generating text only.

Example tools:

• Search engines
• Calculators
• Databases
• Code execution
• APIs

Flow:

Code: [Select]

User query → model → tool request → tool output → model response

Example:

Code: [Select]

"What's the weather?"
→ call weather API
→ return structured result
→ format response

So the model becomes a controller, not just a responder.

---

2. External APIs

APIs extend the model’s capabilities beyond training data.

They provide:

• Real-time information
• Structured data access
• System integration

Examples:

• Flight booking systems
• Financial data feeds
• Web search APIs

Key idea:

Code: [Select]

Model = reasoning layer
API = real-world interface

---

3. Planning Loops

Agents can break tasks into steps and execute them iteratively.

Example loop:

Code: [Select]

1. Understand goal
2. Break into sub-tasks
3. Execute step
4. Observe result
5. Adjust plan
6. Repeat

This creates goal-directed behaviour instead of single-shot responses.

---

4. Chain-of-Thought Orchestration

Chain-of-thought (CoT) is internal reasoning over multiple steps.

In agent systems, this becomes structured orchestration:

• Decomposition of problems
• Intermediate reasoning steps
• Decision checkpoints

Example:

Code: [Select]

Problem → sub-problems → intermediate outputs → final answer

Important distinction:

• CoT = internal reasoning structure
• Orchestration = system-level control flow around it

---

5. Autonomous Agents

An autonomous agent is a system that can:

• Perceive input
• Plan actions
• Use tools
• Execute steps
• Iterate without constant human prompting

Architecture:

Code: [Select]

Goal → Planner → Tool use → Feedback loop → Goal completion

Examples:

• Coding assistants that write and run code
• Research agents that browse and summarise
• Task automation systems

---

6. Memory Stores

Agents often require memory beyond the context window.

Memory systems include:

• Short-term working memory (context window)
• Long-term vector databases
• Summarised conversation logs

How it works:

Code: [Select]

New input → retrieve relevant memories → inject into context → reason

This allows continuity across sessions and tasks.

---

7. Execution Environments

Execution environments allow agents to actually run code or actions.

Examples:

• Python interpreters
• Shell environments
• Containerised systems
• Sandboxed runtimes

This turns AI from:

Code: [Select]

"describing actions"

into:

Code: [Select]

"performing actions"

Key benefit:

• Verifiable outputs
• Real computation
• Tool-verified reasoning

---

Key Insight

Agents are not a new model type — they are a system design layer built on top of LLMs.

Core structure:

Code: [Select]

LLM (reasoning engine)
+ Tools (external capabilities)
+ Memory (state persistence)
+ Planner (task decomposition)
+ Execution (real-world actions)

So instead of a static text generator:

Code: [Select]

You get a goal-directed system that can interact with the world