last week, i deployed an ai agent that now handles the first response to customer issues at my company. instead of tagging me in slack, my team tags the agent. it investigates, searches for existing tickets, asks clarifying questions, gathers context, and creates jira tickets—all autonomously.

here's how i built it in 3 days, and what this means for the future of product management.

the problem: repetitive, but not simple

as a pm, a huge part of my role is triaging customer feedback—especially from our customer service team. when an issue comes in, there's a predictable (but not fixed) workflow: gather context, search for duplicates, ask clarifying questions, create tickets with proper formatting.

it's not creative work, but it's not just "if this, then that" automation either. it requires judgment. you need to know which questions to ask based on the issue type, which existing tickets might be related, and how to structure the information for engineering.

i was spending 1-2 hours a week on this, and my cs team was spending even more time waiting for responses.

why an ai agent?

i've been coding with ai for over a year now, and i use claude code obsessively. i'd already been using the jira mcp (model context protocol) server with claude code to manage tickets, search for issues, and summarize information for myself. it worked incredibly well.

the insight: if this works for me personally, why not make it available to my whole team as a slack bot?

i didn't consider templates, zapier workflows, or hiring someone. modern ai models are extremely capable at this kind of bounded, judgment-based work, and i knew i could build something custom that fit our exact workflow.

more importantly, i wanted conversational intelligence, not hard-coded rules. the claude agent sdk with mcp servers gave me that—the same tools and capabilities i was using in claude code, but packaged as a standalone agent my team could @mention in slack.

the build: 3 days from idea to production

system architecture

flowchart LR
    A[Slack User
@mentions bot] --> B[Slack Bot
Socket Mode]
    B -->|fetch thread
history| B
    B -->|enqueue
message| C[Agent Worker
Queue Processor]
    C -->|build prompt
with context| D[Claude Agent SDK]
    D -->|tool calls| E[MCP Servers]
    E --> F[slack-tools
5 tools]
    E --> G[jira
8 tools]
    F -->|slack_post_message| B
    G -->|jira_create_issue| H[Jira]
                        

key components:

slack bot (socket mode) — websocket connection listening for @mentions and thread replies. fetches full thread history so the agent has context of entire conversations before responding.

claude agent sdk — autonomous operation with haiku (fast/cheap) for standard tasks and sonnet for complex reasoning. system prompt defines behavior and jira conventions.

mcp servers — custom slack tools (post messages, get context, user info) and external jira integration (search, create, update tickets). agent decides which tools to use based on conversation context.

the business case: incredibly cheap

prompt caching keeps costs low. the system prompt, tool documentation, and jira conventions are cached and reused across conversations—resulting in 95%+ cache efficiency. millions of tokens read from cache vs thousands of fresh input.

the results: better than expected

the team started using it immediately. our director of member services said it "does what it's set up to do really well." instead of tagging me with "hey, customer reported x," they now tag the agent first.

the agent does the initial investigation, and i jump into the thread when i have strategic input to add. i'm still paying attention—i'm just not the first responder anymore. high-priority escalations still come to me directly, but for standard triage, the agent is now the default.

roi: ~$25-30/month projected cost for 4-8 hours saved monthly. that's a 10-15x return at conservative pm rates.

what i learned (advice for others)

start small with something specific — you don't need to automate your entire workflow. pick one repetitive task that requires judgment but has bounded scope. mine was cs triage → jira tickets.

it doesn't have to be "if this, then that" — agents can handle critical thinking and contextual decisions. don't limit yourself to simple automation. the whole point is to delegate judgment, not just rote tasks.

use what already works — i didn't build everything from scratch. the jira mcp already existed. slack has great apis. the agent sdk handles tool orchestration. i just connected the pieces.

ship fast, iterate with users — i had the team testing on day 3 while i debugged live. by end of day, it was in production. the feedback loop was immediate and valuable.

what's next: multi-agent architecture

i'm currently refactoring to support multiple specialized agents. here's the progression:

graph LR
    A[CS Reports
Issue] --> B[Triage Agent]
    B --> C[Creates Jira
Ticket]
    C --> D[PM Assigns
to Engineer]
    D --> E[GitHub Agent
Investigates Code]
    E --> F[Points to
Root Cause]
    F --> G[Engineer
Fixes]

    style B fill:#6366f1
    style E fill:#22c55e
    style G fill:#f59e0b
                        

phase 1 (live now): triage agent handles cs reports and ticket creation
phase 2 (building): github agent investigates codebase and points engineers to root cause
phase 3 (future): agent generates and tests fixes (requires mature testing infrastructure)

the ultimate goal? issues get reported, investigated, and resolved by agents. we're not there yet, but it's the logical progression.

the bigger shift: what is product management now?

here's what surprised me most: delegating the triage work didn't make me less busy. it changed what i'm busy doing.

i'm now contributing to production code on jira tickets myself—filling in for our small engineering team using ai-assisted coding. by delegating the coordination work to an agent, i'm free to build more myself. i'm not just managing—i'm shipping code.

that's the shift i didn't expect. the future of pm (at least in small, technical teams) isn't "do less work." it's "shift from coordination to creation."

the agent handles the triage. i handle the building.

if you're thinking about building an agent for your team:

• you don't need to be an expert engineer (i'm not)

• you don't need a huge budget (i spent $8)

• you do need to be comfortable with ai tools and willing to iterate

• start with something small and specific

the tools are here. the models work. the only question is: what repetitive work are you still doing manually?