Last month, our team spent an entire Saturday manually triaging 40 Jira tickets, cross-referencing them with GitHub pull requests, and updating our Confluence runbooks after a particularly messy production deployment. It was the kind of repetitive, cross-tool busywork that makes you think, "Couldn't a script do this?" But a script can't reason about whether a Jira ticket belongs in the "In Progress" or "In Review" column based on the state of a linked PR. That's exactly the problem that led me to Google's Agent Development Kit (ADK).
ADK is Google's open-source framework for building production-grade agents. What caught my attention wasn't the chatbot angle—it was the recent expansion that added direct integrations for the exact tools our DevOps team uses daily: GitHub, Jira, Confluence, MongoDB, and observability platforms. An agent that can actually open a PR, update a ticket, and query a database is fundamentally different from one that just tells you how to do those things. Here's how I built a DevOps workflow agent using ADK.
Getting Set Up
I went with the Python version since our team's infrastructure scripts are already in Python. You'll need Python 3.13 (or a compatible version) and the ADK package.
pip install google-adk
ADK is model-agnostic through LiteLLM integration, supporting over 100 providers including Anthropic and OpenAI. But since it's optimized for Gemini, I started there using gemini-flash-latest for speed and cost efficiency.
You'll also need to set your API key:
export GOOGLE_API_KEY="your-key-here"
Building the Core Agent
The fundamental building block in ADK is the Agent. You define a name, a model, an instruction (the system prompt), and the tools the agent can use. Let's start with a basic DevOps triage agent:
from google.adk import Agent
from google.adk.tools import google_search
devops_agent = Agent(
name="devops_triage",
model="gemini-flash-latest",
instruction="""You are a DevOps workflow assistant. You help the team:
1. Check the status of GitHub PRs and link them to Jira tickets
2. Update Jira ticket statuses based on PR state
3. Search Confluence for relevant runbooks when incidents occur
4. Query MongoDB for deployment metrics
Always confirm before making destructive changes like closing tickets.""",
tools=[google_search],
)
That gives us a conversational agent, but it can't actually touch our tools yet. The real power comes from adding the specific integrations.
Adding DevOps Tool Integrations
This is where ADK's recent expansion shines. The framework now provides direct connections across five categories that map to how DevOps teams actually work. Here's how I wired up the tools we needed:
from google.adk import Agent
# These integration tools are available through ADK's partner ecosystem
from adk_integrations.github import GitHubTool
from adk_integrations.atlassian import JiraTool, ConfluenceTool
from adk_integrations.mongodb import MongoDBTool
devops_agent = Agent(
name="devops_triage",
model="gemini-flash-latest",
instruction="""You are a DevOps workflow assistant for the platform team.
When triaging issues:
- Check GitHub for related PRs using the issue key
- If a PR is merged and deployed, move the Jira ticket to Done
- If a PR is in review, move the ticket to In Review
- Search Confluence for runbooks matching the error or service name
- Query MongoDB deployment_metrics collection for recent deploy status
Always show the user what you're about to change before executing updates.""",
tools=[
GitHubTool(repo="our-org/our-repo"),
JiraTool(project="PLATFORM"),
ConfluenceTool(space="DEVOPS"),
MongoDBTool(connection_string=os.environ["MONGO_URI"]),
],
)
The first surprise I hit: the Jira integration needed OAuth credentials, not just an API token. If you're using Jira Cloud, you'll need to set up an OAuth 2.0 integration in your Atlassian developer console. It took me about 20 minutes of head-scratching before I realized the JIRA_API_TOKEN environment variable I'd set wasn't enough. Here's what you actually need:
export ATLASSIAN_OAUTH_CLIENT_ID="your-client-id"
export ATLASSIAN_OAUTH_CLIENT_SECRET="your-client-secret"
export ATLASSIAN_DOMAIN="your-org.atlassian.net"
Running the Agent with the CLI
ADK comes with an Agents CLI that lets you scaffold, test, and run agents without writing boilerplate. This was genuinely useful—I went from idea to a running agent in minutes.
To scaffold a new agent project:
adk create devops_triage_agent
This generates a project structure with the agent definition, tool configurations, and a basic evaluation setup. Then to run it interactively:
adk run devops_triage_agent
Here's an actual interaction I had during testing:
Me: Check the status of PLATFORM-482 and see if there's a related PR
Agent: I'll check Jira for PLATFORM-482 and search GitHub for related PRs.
[Jira] PLATFORM-482: "Fix memory leak in auth service"
Status: In Progress, Priority: High, Assignee: @sarah
[GitHub] Found PR #347: "Fix auth service memory leak (PLATFORM-482)"
Status: Merged (merged 2 hours ago by @sarah)
Branch: fix/auth-mem-leak → main
This PR has been merged but the Jira ticket is still "In Progress."
Would you like me to move PLATFORM-482 to "In Review" or "Done"?
Me: Move it to Done, it's been deployed already.
Agent: Done. PLATFORM-482 is now in "Done" status.
I also found a runbook in Confluence that might be relevant:
"Auth Service Troubleshooting Guide" — should I link it to the ticket?
That's the kind of workflow that used to take us three Slack messages and someone remembering to update Jira after lunch.
Adding Observability
For production use, you need to know what your agent is actually doing. ADK integrates with observability platforms like AgentOps for session replays and metrics, and Arize AX for production debugging. I wired up AgentOps:
from agentops import track_agent
@track_agent(name="devops_triage")
def run_triage_workflow(issue_key: str):
# Agent execution happens here
result = devops_agent.run(f"Triage {issue_key}")
return result
This gives you session replays—essentially a recording of every tool call, reasoning step, and output the agent made. When the agent incorrectly moved a ticket to "Done" that shouldn't have been (which happened once during testing), I could replay the exact decision chain and see that it misinterpreted a "draft" PR as "merged."
Handling Long-Running Workflows
One thing I didn't anticipate: some DevOps workflows take hours. A deployment can take 30 minutes. A CI pipeline can run for an hour. Standard agent sessions time out. ADK's Restate integration solves this by providing durable, resumable agent sessions. Your agent can kick off a deployment, go dormant, and resume when the deployment completes—without losing context.
This is critical for anything that isn't a quick API call. Our deployment verification agent now starts a deploy, waits for the health check, and then updates the ticket—all in one logical session even if it spans 45 minutes of wall clock time.
Practical Tips and Honest Limitations
After running this in our team for a few weeks, here's what I've learned:
Start with read-only operations. Before letting the agent write to Jira or merge PRs, run it in observation mode where it only reads and suggests actions. We caught several cases where the agent would have made wrong assumptions about ticket states.
Be specific in instructions. "Update tickets appropriately" is too vague. "If a PR is merged and the deploy is confirmed in MongoDB metrics, move the ticket to Done" gives the agent a clear decision tree.
Test with the CLI's evaluation tools. ADK includes evaluation tooling. Write test cases with expected outcomes before deploying. I wish I'd done this from day one instead of finding out the hard way that our agent thought "closed" in GitHub meant the same thing as "Done" in Jira.
The limitations are real. The integrations are new, and some are rougher than others. The GitHub integration is solid, but I ran into edge cases with the Confluence tool where it couldn't search across spaces. The MongoDB tool works for basic queries but struggles with aggregation pipelines. And while ADK is model-agnostic, the experience is noticeably smoother with Gemini—some tool calls failed silently with other providers during my testing.
Cost adds up. An agent that makes 10 tool calls per triage action can burn through API credits fast, especially with the Pro model. Stick to Flash for routine operations and escalate to Pro only when the agent hits a reasoning wall.
Despite the rough edges, ADK delivered on the core promise: our Saturday triage sessions are gone. The agent handles the routine cross-tool updates, and we only step in for the judgment calls. That's the right division of labor between humans and agents—not replacing DevOps engineers, but eliminating the toil that burns them out.