Building a Multi-System Agent Workflow

Overview

This project explores building an AI agent that can orchestrate actions across multiple systems—taking natural language requests and executing multi-step workflows.

The Challenge: How do you build an agent that can:

• Understand requests and break them into tool calls
• Execute actions across different systems (Jira, internal APIs, Slack)
• Handle errors gracefully (retries, rollbacks, partial success)
• Maintain audit logs for compliance

Approach

The agent uses Claude's tool use capability to orchestrate workflows:

1. Parse requests into structured actions
2. Call tools across different systems with least-privilege access
3. Handle errors with retry logic and rollback
4. Log everything for debugging and compliance

How It Works

Example Request:

"Provision dev access for sarah@company.com, update ticket DEVOPS-4231, and notify the team lead."

Agent Workflow:

1. Plan: Break down into steps (validate user, check permissions, call provisioning API, update ticket, send notification)
2. Execute: Call tools sequentially with least-privilege credentials
3. Validate: Confirm each step succeeded before proceeding
4. Report: Return structured summary with audit trail

Architecture

• Agent Controller: LLM-powered planner (Claude) with tool-use capability
• Tool Registry: Standardized interface for each system (Jira, internal APIs, Slack, knowledge base)
• Execution Engine: Retry logic, timeout handling, partial rollback on failure
• Audit Layer: Logs every tool call (input, output, user, timestamp) for compliance

Tools Implemented

• Ticketing: Create, update, assign, close tickets in work management system
• Provisioning API: Grant/revoke access to internal systems
• Knowledge Retrieval: Search internal docs and policies
• Notification: Send Slack messages, email notifications
• Metrics: Query system health, usage stats

What I Learned

1. Tool definitions must be precise Vague tool descriptions led to hallucinated parameters. We standardized tool schemas with explicit examples and validation rules. This cut errors by 40%.

2. Human-in-the-loop for high-risk actions Some actions (deleting data, granting admin access) required human approval. We added a confirmation step that blocks execution until approved—this preserved trust.

3. Partial failures need graceful degradation When one tool call failed, the agent would halt the entire workflow. We added rollback logic and partial success reporting: "Completed steps 1-3, step 4 failed (retrying)."

4. Observability is critical We built a dashboard showing agent activity: success rate per tool, failure modes, execution time. This surfaced bottlenecks and drove continuous improvement.

Technical Details

Agent Loop

1. Parse user request → extract intent + entities
2. Generate execution plan → sequence of tool calls
3. For each tool call:
   - Validate input parameters
   - Execute with timeout
   - Handle errors (retry, rollback, or escalate)
   - Log result
4. Synthesize final response with audit summary

Tool Security

• Each tool had its own service account with minimal permissions
• Tool calls included user context for authorization checks
• Rate limiting prevented abuse
• All outputs were sanitized before returning to user

Takeaways

Building agent workflows is about more than chaining LLM calls. The hard parts are:

• Defining tools precisely enough that the LLM doesn't hallucinate parameters
• Handling partial failures without breaking the entire flow
• Building observability so you can debug when things go wrong
• Balancing automation with human approval for high-risk actions