Inspiration

Most trend dashboards tell you what is trending. We wanted to answer a more useful question:

Where did a name actually print, how are different communities reacting to it, and what evidence can I trust?

Imagine launching a campaign and searching for your product name. One platform is full of excitement, another community is discussing privacy concerns, while another barely mentions it. A traditional trend score can flatten all of that into one number.

We wanted to make those differences visible.

That became the idea behind HawkxAI: a campaign footprint desk where you plug in a name you already care about — a product, campaign, hashtag, or competitor — and the system builds a footprint from real receipts.

The key principle was simple:

Don't let the AI invent the story. Let the evidence tell it.

That means our mind map doesn't create relationships just because an AI model thinks two concepts are related. A connection exists only when we can point to a real shared artifact, such as a URL, hashtag, or other evidence.

The All Things Agentic contest gave us the perfect constraint to turn that idea into an agent-powered system. Instead of building another chatbot, we built an agent fleet that actually does the work: collect, score, cluster, store, and surface evidence.

---

What it does

HawkxAI is an AI-powered campaign footprint desk.

A user plugs in a name they already care about — for example, Camry — and HawkxAI collects public evidence, identifies related names and artifacts, and turns those receipts into three connected experiences.

Footprint — Where did it print?

Footprint shows where a name appears and how different communities connect around it.

The mind map is evidence-driven. A relationship is created only when names share a real artifact. If the evidence is weak, the map stays weak.

Users can also open individual receipts and go directly to the underlying source.

Insights — Where did it start?

Insights takes the same underlying receipts and looks backward.

It identifies the origin, family or context, and oldest dated evidence we can establish.

If a name has multiple meanings, we keep those meanings separate rather than forcing them into one story.

Research — What can I actually cite?

Research turns the same evidence into a concise, source-backed brief.

Instead of giving users an AI-generated explanation with unclear origins, each result can be traced back to its source and collection information.

One tape, three jobs

The important part is that these aren't three separate AI products.

They all operate on the same underlying evidence tape:

Footprint: Where did it print? Insights: Where did it start? Research: What can I cite?

The system also preserves lineage for receipts, including the collection tool and timestamp.

If the evidence isn't there, HawkxAI doesn't manufacture a conclusion.

---

How we built it

We built HawkxAI as two primary Cloud Run services working together.

1. The Desk

The user-facing application is built with Next.js.

Footprint is the main entry point, while Insights and Research consume the same collected evidence.

The architecture intentionally keeps the global trend experience separate from fleet-generated snapshots so that an ingest failure cannot overwrite or corrupt the broader trend experience.

2. The Agent Fleet

The ingestion side is built with Python, Google ADK, Gemini 3.5 Flash, and Cloud Run.

The fleet receives a phrase and coordinates collection from public sources such as:

• Hacker News
• Wikipedia
• Google News RSS
• NHTSA

Gemini is used for classification, clustering, and deduplication of existing evidence.

The model does not get to invent the underlying relationships or numbers.

Those calculations remain in code.

Collected snapshots are stored in Google Cloud Storage, and each receipt maintains lineage such as:

tool + collectedAt

The overall flow looks like this:

User
  ↓
HawkxAI Footprint
  ↓
Agent Fleet
  ↓
Google ADK + Gemini
  ↓
Public Sources
  ↓
Collect → Score → Deduplicate → Store
  ↓
Evidence + Lineage
  ↓
Footprint / Insights / Research

We also built quantitative logic around the evidence rather than asking an LLM to describe a trend.

For example, platform divergence is calculated from the number of platforms where a name has meaningful activity:

$$ D = 1 - \frac{k}{P} $$

where $k$ is the number of platforms with a score above the activity threshold and $P$ is the total platform count.

A value closer to $0$ means the activity is broadly distributed, while a value approaching $1$ indicates a more concentrated footprint.

For trend velocity, we compare the current snapshot with the previous snapshot rather than asking an AI model whether something "feels like it is rising."

When enough user-backed history exists, we can also fit lightweight machine-learning models for occupancy and next-window predictions. Until there is enough evidence, the system intentionally falls back to simpler rules.

Thin data should produce a thin prediction.

---

Challenges we ran into

Building an agent that actually does work

One of our biggest challenges was deciding what the AI should and should not do.

It was tempting to give the model the receipts and ask it to explain what was happening.

But that creates a major trust problem.

We ultimately separated the responsibilities:

Gemini: classify, cluster, and deduplicate evidence.

Code: calculate divergence, velocity, relationships, and lineage.

That boundary became one of the most important architectural decisions in the project.

Serverless execution

Our original desk and agent workloads had very different execution requirements.

The user-facing experience needed to remain fast and interactive, while the agent fleet needed enough execution time to collect and process multiple sources.

We solved this by keeping the desk in Next.js and moving the longer-running agent workload to Cloud Run.

Working with limited data

Some sources simply don't return much information for certain phrases.

That became especially important during our live demo.

We had to make a choice: create an impressive-looking graph with generated relationships, or show the actual evidence even when it was sparse.

We chose the second.

If Camry doesn't have enough evidence, HawkxAI says so.

We would rather show an empty map than a convincing lie.

Building useful ML without pretending we have enough training data

Some of our predictive functionality requires user-backed history.

We therefore designed explicit floors for the models.

Until enough labeled examples exist, the system uses simpler statistical rules instead of pretending that a machine-learning model trained on insufficient data is reliable.

That constraint is intentional.

---

Accomplishments that we're proud of

• Built a live agent-powered footprint desk that accepts a phrase and collects evidence through Cloud Run.
• Integrated Google ADK and Gemini 3.5 Flash into an agent workflow that performs collection, classification, clustering, and deduplication.
• Created an evidence-first mind map where relationships require real shared artifacts.
• Added lineage to collected receipts, including the collection tool and timestamp.
• Built three connected experiences — Footprint, Insights, and Research — on the same evidence tape.
• Implemented code-driven divergence and velocity calculations instead of relying on generated descriptions.
• Added comparison capabilities so users can examine multiple owned names against the same evidence.
• Designed ML functionality with explicit data floors and fallbacks, rather than forcing a model onto insufficient data.
• Built a generated architecture handbook from the actual fleet configuration and permissions.
• Created a system that can degrade gracefully when individual sources are unavailable instead of fabricating missing information.

Most importantly, we built something that demonstrates our core philosophy:

Evidence first. AI second.

---

What we learned

Agents are choreography, not chat

The most useful agent interaction wasn't a conversation.

It was:

collect → stamp lineage → process → store → surface.

The agent became valuable when it was responsible for completing a real workflow rather than simply generating text.

Evidence is a product decision

A completely connected graph looks impressive in a demo.

But if those connections cannot be explained, they aren't useful in the real world.

We learned that sometimes the most trustworthy output is an incomplete one.

User interaction can become the training signal

The phrases users plug in, the names they compare, and the labels they provide can eventually become useful signals for improving the system.

Instead of silently scraping private user behavior, we designed the product around explicit user-backed signals.

Persistence changes everything

A single snapshot can tell you what is happening now.

Multiple snapshots can tell you what changed.

That distinction is critical for measuring divergence, velocity, and eventually building meaningful predictions.

One evidence tape can power multiple products

Footprint, Insights, and Research initially felt like separate features.

As we built them, we realized they are really different questions asked against the same evidence.

That became one of the strongest architectural ideas in HawkxAI:

One plug. One evidence tape. Three different answers.

---

What's next for HawkxAI

Our next step is turning the prototype into a persistent, personalized monitoring system.

Build stronger historical signals

As users create more labeled observations, we can move more predictions from simple fallback rules to trained models.

Add authentication and consent

Watchlists and user labels will become account-specific, allowing users to explicitly control what becomes part of their monitoring and training signals.

Move toward real-time collection

Today, collection is snapshot-based. The next step is increasing collection frequency so users can see meaningful changes throughout the day.

Expand source coverage responsibly

We want to add more channels where campaigns actually live, but only through legitimate public APIs or appropriate authorization.

We don't want "more data" at the cost of reliability or compliance.

Make the footprint persistent

The long-term vision is simple:

Plug in what you own once. Let HawkxAI watch the footprint over time.

Instead of asking an AI every morning, "What's happening with my campaign?", HawkxAI can show you what changed, where it changed, and — most importantly — the receipts behind the change.

HawkxAI is built around one rule that we don't want to compromise:

If the evidence doesn't support the story, don't tell the story.

Built With

• agent
• ai
• audit
• data
• marketing
• python