Building with AI Agents: A Practical Guide Inspired by Spotify and Anthropic

Overview

Agentic development is reshaping how we approach software engineering. When Spotify and Anthropic sat down to discuss their experiences, they highlighted a key shift: moving from traditional deterministic code to systems where AI agents make autonomous decisions within defined boundaries. This guide translates those insights into a step-by-step tutorial for building your own agent-powered workflows.

Prerequisites

• Basic understanding of Python or any programming language
• Familiarity with REST APIs and JSON
• Anthropic API key (or similar LLM provider)
• Python 3.8+ installed on your machine
• pip packages: requests, anthropic (or openai)

Step-by-Step Instructions

1. Define Your Agent's Role and Goals

Before writing code, decide what your agent will accomplish. In Spotify's example, they used agents to automate music recommendation tasks. Start with a clear objective:

• Example goal: An agent that answers user questions about a codebase.
• Scope: Limit the agent to retrieving information from a vector database.
• Constraints: No external API calls unless explicitly allowed.

2. Set Up the Development Environment

Create a project folder and install dependencies:

mkdir agentic-dev
cd agentic-dev
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install anthropic requests flask

3. Build a Minimal Agent Loop

An AI agent typically follows this pattern: receive input → decide action → execute → repeat. Here's a simple loop using Anthropic's Claude:

import anthropic

client = anthropic.Anthropic(api_key="your-api-key")

def agent_loop(user_input):
    response = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=1000,
        messages=[
            {"role": "user", "content": "You are an assistant that answers questions about our codebase. Use the tools available to retrieve information. " + user_input}
        ]
    )
    return response.content[0].text

# Example usage
print(agent_loop("What does the main function do?"))

4. Integrate Tool Use (Function Calling)

To make the agent agentic, it needs tools. Spotify's engineers built tool descriptors that the model can invoke. Add a simple search tool:

def search_codebase(query):
    # Mock implementation
    return "Functions: process_data() in module_a.py"

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_codebase",
            "description": "Search the codebase for a given term",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

def agent_with_tools(user_input):
    response = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=1000,
        tools=tools,
        messages=[{"role": "user", "content": user_input}]
    )
    # Handle tool calls
    for content_block in response.content:
        if content_block.type == "tool_use":
            tool_name = content_block.name
            tool_args = content_block.input
            if tool_name == "search_codebase":
                result = search_codebase(tool_args["query"])
                # Feed result back to agent
                # (simplified - in practice, send a follow-up message)
                return result
    return response.content[0].text

5. Implement Memory and Context Management

Agents need to remember previous interactions. Store conversation history and update the message list:

conversation_history = []

def agent_with_memory(user_input):
    conversation_history.append({"role": "user", "content": user_input})
    response = client.messages.create(
        model="claude-3-haiku-20240307",
        max_tokens=1000,
        messages=conversation_history
    )
    assistant_reply = response.content[0].text
    conversation_history.append({"role": "assistant", "content": assistant_reply})
    return assistant_reply

6. Deploy as a Web Service

Create a simple Flask app to expose your agent:

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route("/ask", methods=["POST"])
def ask():
    data = request.get_json()
    question = data.get("question", "")
    response = agent_with_tools(question)
    return jsonify({"answer": response})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Test with curl:

curl -X POST http://localhost:5000/ask -H "Content-Type: application/json" -d '{"question":"How is data stored?"}'

Common Mistakes

1. Overloading the Agent with Too Many Tools

Add only the tools the agent needs. Too many confuse the model and degrade performance. Start with 2-3.

2. Not Handling API Errors

Always wrap API calls in try/except. A failed tool call can break the agent loop:

try:
    result = search_codebase(query)
except Exception as e:
    result = f"Error: {str(e)}"

3. Ignoring Token Limits

Agentic systems accumulate conversation history quickly. Implement a sliding window or summarization step to stay within token limits.

4. Missing Permission Boundaries

Spotify emphasized defining strict boundaries for agents. Never give an agent unrestricted access to production data or operations without human validation.

Summary

Building with AI agents requires a shift in mindset: you're now orchestrating autonomous decision-makers. Start small with a single purpose, iterate on tools and memory, and always enforce safety constraints. The Spotify x Anthropic conversation showed that the most successful agentic systems are those that balance freedom with guardrails. Use this guide as a starting point, and soon you'll be designing agents that amplify your development workflows.