Agentic Evolution: From Traditional Software to Agentic Software

Are you building traditional software? Most likely, yes.

But a shift is underway towards agentic software. Understanding this transition is becoming essential.

Consider Docker’s recent AI Agent update. Docker, a quintessential traditional software tool, introduced an AI agent. What’s significant is how this agent exposes its capabilities—like managing containers or running security scans—using Anthropic’s Model Context Protocol (MCP).

MCP is an open standard designed to standardize how applications provide context and functions to large language models (LLMs) and AI agents. It defines a client-server protocol where an AI client (like Docker’s agent, Claude Desktop, or Cursor) requests actions or context from an MCP server. The server executes code, calls APIs, or retrieves data to fulfill the request.

Docker’s AI agent uses MCP to offer a suite of tools. These functions cover:

• Container, volume, image, pod, deployment, and service management.
• Cluster information retrieval (namespaces, nodes).
• Docker Scout security scanning (CVE searches, recommendations).
• Developer utilities (fetching resources, running commands).
• AI model management (listing, pulling, running local models).

Crucially, Docker’s agent doesn’t just use MCP; it can act as an MCP server itself. This exposes its built-in tools to other MCP-compatible clients. A simple configuration allows systems like Claude Desktop to leverage Docker’s capabilities directly through the agent.

{
  "mcpServers": {
    "gordon": {
      "command": "docker",
      "args": ["ai", "mcpserver"]
    }
  }
}

Example: Configuring Claude Desktop to use Docker’s agent tools via MCP.

Why is this significant?

Docker’s move clearly illustrates the transition from traditional to agentic software. Here’s how agentic software differs:

1. Empowerment through Agents: It provides users with AI agents or agentic workflows, moving beyond fixed interfaces.
2. Focus on Functions/Tools: Business logic and capabilities are refactored into discrete functions (tools) that agents can use. Traditional workflows become callable components.
3. Dynamic Execution: Instead of rigid, pre-defined workflows, AI agents dynamically select and sequence these tools to achieve goals, deciding the ‘how’ based on the context.
4. Interoperability: By exposing tools via standard protocols like MCP, agentic software enables agents to collaborate and interact seamlessly with other agents and third-party systems.

Traditional software dictates how a task is done through fixed workflows. Agentic software defines what tasks can be done (the functions or tools) and empowers AI agents to determine the best way to execute them.

This shift towards function-calling, tool use, and standardized agent communication marks a fundamental evolution in software design. It’s time to consider how your own software might embrace agentic principles.