DEV Community: Aadil Lone

Automating Coaching Notes with an ADK Agent on Cloud Run

Aadil Lone — Fri, 21 Aug 2026 22:37:46 +0000

Gen AI Academy APAC — Track 3 (Automate Daily Operations with a Productivity Agent)

Why this one

Between the escalation classifier (Track 1) and the BigQuery insights agent (Track 2), the missing piece was the most repetitive part of my actual day: writing coaching messages.

Every time I review a case with an agent, I end up writing some version of the same message — acknowledge what went right, name the specific gap, give one clear next step. Multiply that by 25 agents and however many cases come up in a week, and it's a real chunk of time spent on the same structural task over and over.

Track 3 is specifically about automating that kind of repetitive daily-operations work, so this felt like the right fit.

What it does

You give the agent rough, unpolished notes — the kind of thing you'd actually jot down in the moment:

Agent: Priya. Notes - handled a refund case fine but took 25 min because kept checking with me on things she should know by now. 3rd time this month. good with customer tone though.

And it returns a ready-to-send coaching message:

{
  "tone_used": "standard",
  "coaching_message": "Priya, you handled the customer's tone excellently on the recent refund case. However, it took 25 minutes because you needed to confirm standard procedures, which is something we've noticed a few times this month. To improve efficiency and your confidence, please review the refund policy documentation in our knowledge base. Let's aim to resolve these types of cases independently going forward.",
  "one_line_summary": "Priya needs to review refund procedures to improve efficiency and reduce reliance on supervisor checks."
}

Notice it picked up on "3rd time this month" and named it as a pattern on its own, kept the genuine praise about customer tone instead of dropping it, and landed on one specific actionable step rather than a vague "keep improving."

How it's built

Same core pattern as Track 1 — ADK + Gemini, deployed on Cloud Run — but with one addition: a small tool that returns tone guidelines (standard / sensitive / recognition) so the agent can pick the right register depending on whether this is routine feedback, a repeat/fragile situation, or positive reinforcement, rather than using one flat tone for everything.

def get_tone_guidelines() -> dict:
    """Returns the standard tone guidelines for coaching messages."""
    return TONE_GUIDELINES

The agent calls this before drafting, same as the taxonomy lookup did in Track 1.

What stood out

Reusing the same project's IAM setup from Track 1 and 2 made this deployment trivial. No permission errors at all this time — a good reminder that most of the friction in Track 1 was one-time setup cost, not something inherent to Cloud Run deployments.
A small "pick the right tone" tool did more work than expected. Without it, the model defaulted to a flat, uniformly gentle tone regardless of context. Giving it explicit categories to choose from made the output noticeably more appropriate to what was actually being described.
This is the track that would get used the most, day to day. Root-cause classification and BigQuery insights are valuable but periodic; a coaching-note drafter is something I'd genuinely reach for multiple times a day.

Try it / see the code

Live agent (Cloud Run): https://coaching-note-drafter-507816071353.us-central1.run.app
Source code: https://github.com/aadilmajeedlone/coaching-note-drafter

What's next

Combine all three tracks: Track 1 classifies the escalation, Track 2's BigQuery pipeline tracks the pattern over time, and this agent drafts the coaching note automatically as soon as a case is flagged — turning three separate tools into one pipeline that goes from raw case to sent message with a single review step in between.

Built for the Google Cloud Gen AI Academy APAC program, in partnership with Hack2Skill.

Turning Escalation Data into Strategic Decisions with Gemini in BigQuery

Aadil Lone — Fri, 21 Aug 2026 22:06:05 +0000

Gen AI Academy APAC — Track 2 (Turn Business Data into Strategic Decisions)

Why this one, and why it builds on Track 1

For Track 1, I built an agent that classifies individual customer service escalations one at a time. That's useful for reviewing a single case — but as a team lead managing 25 agents, the real question I ask most weeks isn't about one case. It's "what's actually going wrong across all of them, and what should I do about it?"

That's a data question, not a single-case question — which made it a natural fit for Track 2's focus: using Gemini directly inside BigQuery to go from raw data to an actual recommendation, without needing a separate app or notebook.

What I built

Loaded 70 real-shaped escalation cases into BigQuery — same dataset structure as Track 1 (case ID, summary, agent, channel).
Classified every case with Gemini, directly in SQL, using AI.GENERATE():

SELECT case_id, agent_id, channel, summary,
  AI.GENERATE(
    prompt => CONCAT(
      'Classify this customer service escalation into exactly one of: ',
      'policy_misapplication, process_gap, communication_breakdown, ',
      'system_limitation, training_gap, customer_expectation_mismatch. ',
      'Respond with only the category name. Case: ', summary
    ),
    connection_id => 'us-central1.cx_gemini_conn',
    endpoint => 'gemini-2.5-flash'
  ).result AS root_cause
FROM `cx_insights.escalations`

No separate agent deployment needed for this part — the classification happens where the data already lives.

Fed the aggregated results back into Gemini to generate an actual strategic recommendation, not just a chart:

SELECT AI.GENERATE(
  prompt => CONCAT(
    'You are a customer service operations analyst. Based on this ',
    'root cause breakdown across 70 escalations, write a 3-4 sentence ',
    'strategic recommendation for a team lead managing 25 agents. ',
    'Be specific and actionable. Data: ',
    (SELECT STRING_AGG(FORMAT('%s: %d cases', root_cause, cnt), ', ')
     FROM (SELECT root_cause, COUNT(*) AS cnt
           FROM `cx_insights.escalations_classified`
           GROUP BY root_cause))
  ),
  connection_id => 'us-central1.cx_gemini_conn',
  endpoint => 'gemini-2.5-flash'
).result AS strategic_recommendation

The result, generated directly from the data — no manual analysis in between:

"The primary drivers of escalations are training gaps (20 cases) and system limitations (15 cases). The team lead should prioritize a comprehensive review and enhancement of agent training, focusing on areas directly impacted by these gaps, perhaps through targeted workshops or updated knowledge base articles. Simultaneously, they must collaborate with relevant departments to identify and address the most impactful system limitations, providing agents with temporary workarounds and clear communication regarding ongoing resolutions."

That's genuinely close to the kind of recommendation I'd write myself after a manual review — except it took seconds instead of an hour of reading through cases individually.

What stood out

AI.GENERATE inside plain SQL is a low ceremony way to add reasoning to data you already have. No separate service, no agent framework — just a function call in a query.
The two-step pattern (classify → aggregate → summarize) is more useful than either step alone. Per-case classification is Track-1-style detail; the aggregated recommendation is what actually changes what a team lead does Monday morning.
Connection setup (BigQuery ↔ Vertex AI) was the fiddly part, similar to the IAM friction from Track 1's Cloud Run deployment — worth budgeting time for on a fresh project.

Try it / see the queries

Source project: https://github.com/aadilmajeedlone/escalation-root-cause-agent (same repo as Track 1 — the BigQuery queries and dataset setup are documented alongside the agent code)

What's next

Combining both tracks: have the Track 1 agent write directly into this BigQuery table as escalations come in, so the strategic recommendation query always reflects the current week rather than a static export — a live dashboard for the team, not a one-off report.

Built for the Google Cloud Gen AI Academy APAC program, in partnership with Hack2Skill.

Building an Escalation Root-Cause Agent with Gemini and ADK

Aadil Lone — Fri, 21 Aug 2026 21:20:28 +0000

Gen AI Academy APAC — Track 1 (AI Agents with Gemini, ADK, and Cloud Run)

Why I built this

I lead a customer service team of 25 agents at Amazon, handling both
buyer-side and marketplace seller support. A big part of my job is
reviewing escalated cases — calls or chats where a customer asked for
a supervisor — and figuring out why they escalated in the first
place. Was it a policy gap? A training issue? A system limitation
nobody flagged?

Right now, that review is manual. Every escalation gets read, tagged,
and turned into a coaching note by a human — usually me, or one of my
leads. It works, but it doesn't scale well, and patterns across dozens
of cases are easy to miss when you're reviewing them one at a time
between everything else on your plate.

So for Track 1 of the Gen AI Academy APAC program, I built an agent
that does the first pass of this analysis automatically: read an
escalation summary, classify the root cause against a standard
taxonomy, flag whether it looks like a repeat pattern, and draft a
coaching note — the same way I would, just faster and more
consistently.

What it does

The agent takes a case summary like this:

Customer requested a refund for a damaged item outside the standard
return window. Agent denied it citing policy; customer says a rep
last month approved a similar exception for someone else.

And returns a structured analysis:

{
  "root_cause_category": "policy_misapplication",
  "severity": "medium",
  "is_likely_repeat_pattern": true,
  "pattern_reasoning": "Inconsistent policy application across agents
  suggests a training or documentation gap rather than an isolated
  error.",
  "coaching_note": "..."
}

It's built on Google's Agent Development Kit (ADK) with Gemini
as the underlying model, and deployed as a live service on Cloud
Run. The agent has one tool — a lookup function for the standard
root-cause taxonomy — which keeps the categories consistent and easy
to update without touching the core prompt.

For batch review, I also built a runner script that processes a whole
CSV of cases at once and outputs a summary report — closer to how I'd
actually use this day to day, reviewing a batch of the week's
escalations rather than one at a time.

What I learned building it

A few things stood out going through this:

Getting the taxonomy right mattered more than the prompt engineering. Once I had six clear, non-overlapping root-cause categories with real definitions, the model's classifications got noticeably more consistent.
Structured output is where this becomes actually useful. Free-text analysis is fine to read once; a fixed JSON shape is what lets you aggregate patterns across dozens of cases and actually spot something you'd have missed manually.
Deployment had more friction than the coding did. Getting a fresh Google Cloud project's IAM permissions set up correctly for Cloud Build and Artifact Registry took longer than writing the agent itself — worth knowing going in if you're new to GCP.

Try it / see the code

Live agent (Cloud Run): https://escalation-root-cause-agent-507816071353.us-central1.run.app
Source code: https://github.com/aadilmajeedlone/escalation-root-cause-agent

The repo includes a README.md with full setup instructions if you
want to run it yourself, plus a sample CSV of synthetic escalation
cases to test against (no real customer data used anywhere in this
project).

What's next

The natural extension is Track 2 — instead of feeding it a CSV
manually, connect it directly to a real ticketing system via MCP so
it can pull escalations and analyze them without a manual export
step. That's the version I'd actually want running against my team's
queue.

Built for the Google Cloud Gen AI Academy APAC program, in
partnership with Hack2Skill.