Exploring Agentic Tool Use with Claude

In previous lessons, you learned to navigate Claude Code's interface and discovered Claude's extensive knowledge of Python and data visualization libraries. You saw how Claude answers questions about Matplotlib, explains concepts, and provides code examples.

However, Claude Code is fundamentally different from standard chat interfaces like ChatGPT. Claude Code isn't just conversational—it's an agentic AI that can actually perform tasks autonomously on your behalf. This is a crucial distinction that changes how you'll work with Claude for data visualization projects.

Think of it this way: a standard chat interface is like a colleague who explains what you should do and provides code snippets, but you do all the work yourself. An agentic AI is like a colleague who can actually sit at your computer and do the work directly. You describe what you want, and Claude creates files, runs code, checks results, and makes adjustments.

When we say Claude is "agentic," we mean it can take action in your computing environment. Instead of just suggesting code, Claude can create files, modify existing code, execute Python scripts, search the web, and verify results. Most importantly, Claude can use these capabilities in a loop—perform an action, check the result, decide what to do next, and continue until the task is complete.

This agentic capability is particularly powerful for data visualization. When you ask Claude to create a plot, it writes the Python file, executes it, verifies the image was created, and can modify the code if you want changes. Claude handles the entire workflow autonomously.

In this lesson, you'll discover what tools Claude has available and how it uses them to complete data visualization tasks. You'll see real examples of Claude creating files, running code, and using multiple tools together in coordinated workflows. By the end, you'll understand how to leverage Claude's agentic capabilities to make your work faster and more efficient.

The best way to understand Claude's capabilities is to ask directly. Open Claude Code and ask:

> What tools do you have available?

Claude responds with a comprehensive list organized by category:

● I have access to the following tools:

  File Operations

  - Read - Read files from the filesystem (supports code, images, PDFs, Jupyter notebooks)
  - Write - Create new files
  - Edit - Modify existing files with exact string replacement
  - NotebookEdit - Edit Jupyter notebook cells
  - Glob - Find files using pattern matching (e.g., **/*.js)
  - Grep - Search for code patterns using regex

  Command Execution

  - Bash - Execute shell commands (git, npm, docker, etc.)
  - BashOutput - Monitor output from background commands
  - KillShell - Terminate background processes

  Web Access

  - WebSearch - Search the web for current information
  - WebFetch - Fetch and analyze web page content

  Task Management & Planning

  - TodoWrite - Create and manage task lists to track progress
  - Task - Launch specialized agents for complex tasks (exploration, planning, documentation lookup)
  - AgentOutputTool - Retrieve results from background agents
  - EnterPlanMode - Enter planning mode for complex architectural decisions
  - ExitPlanMode - Complete planning and get user approval

  User Interaction

  - AskUserQuestion - Ask clarifying questions with multiple choice options
  - SlashCommand - Execute custom slash commands
  - Skill - Execute specialized skills

  I'm designed to help with software engineering tasks like writing code, debugging, refactoring, exploring codebases, running
  tests, managing git operations, and more. What would you like help with?

For data visualization work, you'll primarily use three categories:

• File Operations: Create, read, and modify files
• Command Execution: Run Python scripts and verify outputs
• Web Access: Search for current information and latest documentation

What makes this powerful is that Claude decides which tools to use based on your request. You just describe what you want, and Claude autonomously selects and uses the appropriate tools.

Before Claude can perform actions in your environment, you need to understand tool permissions. Because some of Claude's tools can perform real actions on your system, you control when Claude uses these capabilities.

The first time Claude attempts a tool that requires approval, you'll see a permission prompt. Let's see this in action by asking Claude to use the WebSearch tool:

> Research what is the latest version of matplotlib

When Claude attempts to search the web, you'll see a permission prompt:

● I'll search for the latest version of matplotlib for you.

● Web Search("latest matplotlib version 2025")

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 Tool use

   Web Search("latest matplotlib version 2025")
   Claude wants to search the web for: latest matplotlib version 2025

 Do you want to proceed?
 ❯ 1. Yes
   2. Yes, and don't ask again for Web Search commands in /usercode/FILESYSTEM
   3. No, and tell Claude what to do differently (esc)

This prompt gives you three options:

• Option 1 (Yes): Allows this specific action but will ask again next time
• Option 2 (Yes, don't ask again): Grants permission for similar future actions within your current directory—the exact scope varies by tool (for example, editing a specific file path, or running bash commands matching a pattern)
• Option 3 (No): Denies the request and lets you provide alternative instructions

For most data visualization work, selecting Option 2 for commonly-used operations streamlines your workflow. You'll grant permission once for each type of action, and Claude can work more fluidly without repeated prompts.

Tip: If you want to pre-configure permissions before starting Claude Code, you can create a settings file (.claude/settings.json in your project) that specifies which tools are pre-approved. This is useful for teams or repeated workflows, but for most users, responding to prompts as they appear works well.

Once you grant permission, Claude proceeds with the tool use and returns an answer:

● Web Search("latest matplotlib version 2025")
  ⎿  Did 1 search in 19s                                                                                                       

● The latest version of matplotlib is 3.10.7, released in October 2025. This is the current stable release in the 3.10.x series.

  You can install it with:
  pip install matplotlib

  Or upgrade to the latest version:
  pip install --upgrade matplotlib

  Sources:
  - https://pypi.org/project/matplotlib/
  - https://matplotlib.org/stable/users/release_notes.html
  - https://github.com/matplotlib/matplotlib/releases
  - https://matplotlib.org/

Notice what Claude did:

• Executed the web search with your approved query
• Processed the search results in real time (took 19 seconds)
• Synthesized information into a clear answer
• Provided installation commands
• Cited sources for verification

Use WebSearch strategically. For standard data visualization tasks using established features, Claude's built-in knowledge is sufficient and faster. Save web searches for when you need current information—latest library versions, new features, specific error solutions, or recent visualization techniques.

Now let's see the file operation tools in action. These are fundamental to data visualization work. Ask Claude to create a simple script:

> Create a Python file called plot_basic.py that generates a simple line plot showing the numbers 1 through 10.

Claude creates the file autonomously:

● I'll create a Python file that generates a simple line plot of the numbers 1 through 10.

● Write(plot_basic.py)
  ⎿  Wrote 15 lines to plot_basic.py  
     import matplotlib.pyplot as plt
     # Data: numbers 1 through 10
     numbers = list(range(1, 11))
     # Create the plot
     plt.plot(numbers)
     plt.xlabel('Index')
     plt.ylabel('Value')
     plt.title('Numbers 1 through 10')
     … +5 lines (ctrl+o to expand)

● Created plot_basic.py! The script will generate a line plot showing the numbers 1-10.

  To run it, you'll need matplotlib installed:
  pip install matplotlib
  python plot_basic.py

  The plot will display the values 1-10 on the y-axis against their index positions on the x-axis.

Notice what Claude did:

• Explained its plan before taking action
• Used the Write tool to create plot_basic.py
• Wrote complete, working code to the file
• Showed a preview of the code
• Confirmed the file was created successfully
• Provided instructions for running the script

The file actually exists on your filesystem now—Claude created it autonomously without you needing to open a text editor or save anything manually.

Now let's modify the file. Ask Claude:

> Modify it to save the output as first_plot.png

Claude uses two tools in sequence:

● Read(plot_basic.py)
  ⎿  Read 15 lines

● Update(plot_basic.py)
  ⎿  Updated plot_basic.py with 2 additions and 2 removals
       10    plt.title('Numbers 1 through 10')
       11    plt.grid(True)
       12    
       13 -  # Display the plot
       14 -  plt.show()
       13 +  # Save the plot
       14 +  plt.savefig('first_plot.png')

● Done! The script now saves the plot as first_plot.png instead of displaying it. When you run the script, it will create the
  image file in the current directory:

  python plot_basic.py

Notice the workflow:

• Read the existing file to understand the current code
• Update the file with precise changes (the edit tool is displayed as Update in Claude's output)
• Show exactly what changed (minus signs for removed lines, plus signs for added lines)
• Preserve the rest of the code structure and formatting

This is characteristic of Claude's agentic approach—it first gathers context, then makes surgical modifications without rewriting the entire file.

The real power of Claude's agentic capabilities appears when it can execute code and verify results. The Bash tool allows Claude to run shell commands. Ask Claude:

> Run it

Claude executes and verifies:

● Bash(python plot_basic.py)
  ⎿  (No content)

● Bash(ls -lh first_plot.png)
  ⎿  -rw-r--r--. 1 runner runner 21K Dec  8 17:45 first_plot.png

● Perfect! The script ran successfully and generated first_plot.png (21KB). The plot has been saved to your current directory

Notice the verification steps:

• First Bash call: Ran python plot_basic.py to execute the script
• Result shows "(No content)" because the script succeeded silently
• Second Bash call: Ran ls -lh first_plot.png to verify the output file
• Confirmed the file exists and checked its size (21KB)

This verification step is characteristic of agentic behavior—Claude doesn't just perform actions, it confirms those actions had the intended effect. The Bash tool gives Claude access to all command-line operations—running scripts, installing packages, using version control, and more.

Here's the plot that Claude generated:

Let's observe how Claude orchestrates multiple tools for a more complex task. Ask Claude:

> Create a scatter plot from random data and save it

Watch Claude handle this autonomously:

● Write(plot_scatter.py)
  ⎿  Wrote 19 lines to plot_scatter.py        
     import matplotlib.pyplot as plt
     import numpy as np
     # Generate random data
     np.random.seed(42)  # For reproducibility
     x = np.random.rand(50)
     y = np.random.rand(50)
     # Create scatter plot
     plt.figure(figsize=(8, 6))
     … +9 lines (ctrl+o to expand)

● Bash(python plot_scatter.py)
  ⎿  (No content)

● Bash(ls -lh scatter_plot.png)
  ⎿  -rw-r--r--. 1 runner runner 32K Dec  8 17:47 scatter_plot.png

● Done! Created plot_scatter.py and generated scatter_plot.png (32KB). The scatter plot shows 50 random data points with x and y
   values between 0 and 1.

This demonstrates the complete agentic workflow. Notice the coordinated sequence of actions:

1. Interpreted your high-level request ("create a scatter plot from random data")
2. Planned the implementation (file creation, execution, verification)
3. Created plot_scatter.py with the Write tool
4. Executed the script with the Bash tool
5. Verified the output file was created with Bash again
6. Confirmed success with file size and details

Claude also made autonomous decisions about implementation details:

• 50 data points: Enough to show patterns without clutter
• Figure size 8x6 inches: Clear and readable dimensions
• Random seed (42): For reproducibility
• Output filename: Descriptive scatter_plot.png

You just described the end goal—Claude figured out how to accomplish it. This is the agentic loop in action: create, test, verify, confirm success.

Here's the scatter plot that Claude created:

You've just learned something fundamental about Claude Code. It's not just a knowledgeable assistant—it's an agentic AI that autonomously performs tasks in your computing environment. The tools you explored—Write, Read, Update, Bash, and WebSearch—work together in coordinated workflows. What makes Claude truly agentic is the loop: it creates files, runs code, checks results, and confirms success.

As you move into practice exercises, you'll experience this firsthand. Instead of copying and running code yourself, you'll ask Claude to perform tasks and watch it use its tools autonomously. Experiment with different requests—from simple plots to complex multi-panel visualizations—and observe how Claude breaks down tasks, selects tools, and verifies results.