Architecting Agentic AI Workflows with Spring AI and Tanzu: From Chat to Action

Introduction: Beyond the Prompt

​The era of single-turn prompts is over. Enterprise AI teams are now building agentic applications—software that can reason, remember, and act over multiple steps using tools, memory, and context.

But while public cloud tools like LangChain and open-source agent runtimes are popular for prototyping, they rarely meet enterprise standards for security, observability, and operational control.
​
Enter VMware Tanzu and Spring AI 1.0: a fully integrated, production-ready framework for deploying agentic AI workflows on a secure Kubernetes platform, backed by VMware Cloud Foundation (VCF).

What Makes an App "Agentic"?

Agentic apps move beyond simple LLM queries. They:

• Chat: Accept natural language input
• Reason: Use tools, memory, and context to make decisions
• Act: Perform real-world functions (API calls, database writes, message sends)
• Adapt: Maintain state, loop over steps, and retry if needed

​VMware’s Model Context Protocol (MCP) is an emerging framework designed to standardize how AI agents manage and retrieve context across tools like vector databases, LLMs, and business APIs. Together with the Spring AI SDK, MCP allows developers to orchestrate multi-step agentic workflows using familiar Java patterns—delivered securely and observably via Tanzu Platform.

What is MCP?

The Model Context Protocol is a VMware-led effort to define a common interaction layer between AI agents and their context sources—like memory, policy systems, or vector databases. MCP enables reusable patterns for orchestrating agentic behavior securely, with full platform observability and control.

Tanzu Platform: Ideal for Agentic Architecture

​Layer

• ​Execution
• Reasoning
  
  
• Context & Memory
• Action
  ​
• Observability
• Security

​Tanzu Feature

• ​Spring Boot + Buildpacks (cf push)
• ​Spring AI + LLM Brokers (OpenAI, Claude, Hugging Face)
• Vector DBs (via Data Services), MCP
• REST endpoints, messaging (RabbitMQ/Kafka), service bindings
• Aria Operations, Spring Actuator/Micrometer
• RBAC via brokers, NSX microsegmentation, Tanzu Supply Chain Security

Use Case: Expense Approval Agent

Scenario:
A Spring AI-based chatbot handles expense approvals:

1. Accepts natural language request
2. Checks policy vector DB for thresholds
3. Invokes approval API if valid; escalates otherwise
4. Logs the request for audit

Architecture Diagram

Spring AI + MCP Code Example

@Tool(name = "submitExpense")
public class ExpenseApprovalTool {
  private final ExpenseService client;

  public ExpenseApprovalTool(ExpenseService client) {
    this.client = client;
  }

  public String submit(@Param("amount") double amount, @Param("category") String category) {
    return client.approveOrEscalate(amount, category);
  }
}

@Autowired
ChatClient chat;

public String handleRequest(String userInput) {
  Prompt prompt = chat.prompt()
    .user(userInput)
    .tool(ExpenseApprovalTool.class)
    .call();

  return prompt.content();
}

# manifest.yml for Tanzu deployment
applications:
 - name: expense-agent
   path: target/expense-agent.jar
   memory: 1G
   buildpacks:
     - java_buildpack
   services:
     - vector-db
     - llm-provider
     - mcp-service

​Governance & Observability

• Audit trail: Every LLM call, vector DB query, and API invocation is logged via Aria Ops and Spring Actuator.
• Access control: Only pre-approved service bindings (via brokers) are allowed; RBAC enforced at broker level.
• Drift management: Spring AI + Tanzu Supply Chain Security ensures versioned, signed, reproducible builds.

Agentic AI is more than just chaining LLMs. With Spring AI and VMware Tanzu, you can deploy intelligent, secure, and governed workflows into production, in hours, not months.
​
No glue scripts. No platform sprawl. Just code, chat, and action, on infrastructure you already trust.