Project Info

GroundTruth

Inspiration

I'm a certified drone pilot, and I've spent real hours flying missions where the actual hard part wasn't flying the drone, it was everything around it: knowing what to do the second something goes wrong mid-flight. A battery dips faster than expected, weather shifts, and suddenly you're improvising. Now imagine that same moment, but multiplied across a whole fleet of drones at once, which is exactly where the industry is headed. New FAA rules just made it legal to fly entire fleets without a pilot watching every single drone. But nobody's built the thing that handles "something just went wrong" when there's no human watching closely enough to catch it. So we built it.

What it does

Groundtruth is an autonomous coordination layer for drone fleets. Each drone runs as its own independent AI agent, holding its own battery, position, and task queue. When something goes wrong, a drone's battery drops critical, a weather cell rolls in, you just type it into a chat: "Drone-2's battery has dropped critical, reassign its remaining tasks." The Coordinator agent queries every drone for its live status, Claude reasons over the whole fleet under hard safety rules (never hand a task to a drone that can't safely take it), and replies with a clear reassignment plan and a quality score, all live, all inside a single chat conversation. It also remembers: every resolved incident gets stored, so next time something similar happens, it recalls what worked before instead of starting from zero.

How we built it

Each drone is a uAgents agent registered on Fetch.ai's Agentverse, reachable through ASI:One via the Agent Chat Protocol. A Coordinator agent fans out structured status requests to the whole fleet, collects every drone's response, and hands that live state to Claude (Sonnet 4.6), which returns a structured reassignment plan with a written rationale. RedisVL backs a vector memory layer, every resolved incident gets embedded and stored, and new disruptions pull up semantically similar past incidents as context, even when worded completely differently. Arize traces every single Claude call and runs an LLM-as-judge evaluator that scores each plan against our safety rules, live, in their dashboard. A lightweight dashboard renders the whole fleet and the latest plan visually, polling the same data the agents produce.

Challenges we ran into

The drones weren't all answering at once. We told the coordinator to ask all 3 drones their status, but a setting in the framework made it only listen to one reply at a time instead of all three. Fixed by flipping that setting. The drones weren't all answering at once. We told the coordinator to ask all 3 drones their status, but a setting in the framework made it only listen to one reply at a time instead of all three. Fixed by flipping that setting. We were checking for replies too fast. We'd ask the drones, wait 2 seconds, then give up and move on, but sometimes a drone's answer hadn't arrived yet. Gave it a little more time to wait, fixed it. We were checking for replies too fast. We'd ask the drones, wait 2 seconds, then give up and move on, but sometimes a drone's answer hadn't arrived yet. Gave it a little more time to wait, fixed it. We broke our own test by accident. We wiped the memory database to test something, but the program was still running and didn't know the memory got wiped, so it kept acting like there was no memory at all, when really we'd just confused our own system. Restarted everything cleanly and it worked. We broke our own test by accident. We wiped the memory database to test something, but the program was still running and didn't know the memory got wiped, so it kept acting like there was no memory at all, when really we'd just confused our own system. Restarted everything cleanly and it worked.

Accomplishments we're proud of

Watching the system handle a genuinely hard edge case correctly: when every drone in our fleet was simultaneously low on battery, it refused to force an unsafe reassignment and told us to dispatch backup drones instead, real judgment, not forced productivity. Everything is real and verifiable, not staged: you can watch the actual Claude reasoning trace and safety score live in Arize, and watch it recall a past incident live in the chat. Getting true concurrent multi-agent negotiation working, not just a single LLM call dressed up as "agents." A full Redis vector memory loop confirmed working end to end: store an incident, recall it later via semantic similarity, even when worded completely differently.

What we learned

That getting multiple AI agents to genuinely negotiate with each other is a different problem than just calling an LLM in a loop, concurrency, timing, and message protocols matter as much as the reasoning itself. We also learned that giving an AI system memory of its own past decisions doesn't just make it smarter, it makes its decisions more consistent and easier to trust, which matters a lot when the decisions are safety-related.

What's next

Voice input via Deepgram, so a fleet operator can report a disruption hands-free instead of typing, genuinely useful for someone out in the field. A HazardAgent that detects disruptions proactively from battery and weather trends, instead of waiting for a human to type one in. Scaling the fleet size and adding more disruption types (equipment failure, no-fly zone changes) to stress-test the negotiation logic further. The actual business: Groundtruth as per-drone-per-month fleet-coordination software sold directly to commercial drone operators, the same pricing model fleet management software already uses in trucking and logistics, built for a market that's about to need this badly as multi-drone operations scale.

Groundtruth — Swarm Tasking

Advisory coordination infrastructure for commercial drone inspection fleets.

When something goes wrong mid-mission — a drone's battery hits critical, a weather cell rolls over part of a solar farm — Groundtruth renegotiates task assignments across the fleet in real time and hands a human fleet manager a clear, plain-English reassignment plan. It assists the operator; it does not fly the aircraft. Authority over flight decisions stays with the human.

The entire workflow is demonstrable inside an ASI:One chat conversation: you describe the disruption, and the coordinator queries the live fleet, reasons over its state with Claude, recalls how similar past incidents were resolved, and replies with a scored plan.

Why this matters

Commercial drone operators (solar/utility inspection, agricultural survey, infrastructure, post-disaster mapping) are scaling from single-drone to multi-drone operations as BVLOS waivers expand — but coordination today is usually a person watching several screens. Groundtruth is fleet-coordination software, priced per-drone-per-month like fleet management in trucking/logistics.

Architecture

                ASI:One chat  (the human fleet manager)
                       │  "Drone-2 battery critical, reassign its tasks"
                       ▼
          ┌─────────────────────────────┐
          │      SwarmCoordinator        │  uAgents + Agent Chat Protocol
          │        (mailbox agent)       │  → discoverable on Agentverse / ASI:One
          └─────────────────────────────┘
            │ 1. fan-out StatusRequest        ▲ 4. combined fleet status,
            ▼    to every drone               │    plan, and quality score
   ┌──────────┐ ┌──────────┐ ┌──────────┐
   │ Drone-1  │ │ Drone-2  │ │ Drone-3  │     each: battery %, position,
   │  :8001   │ │  :8002   │ │  :8003   │     current task, queue, capacity
   └──────────┘ └──────────┘ └──────────┘
                       │ 2. collect StatusResponses
                       ▼
          ┌─────────────────────────────┐
          │   Claude reasoning + memory  │
          │                              │
          │  • RedisVL vector memory ───▶ recall similar past incidents
          │  • Claude (Sonnet 4.6) ─────▶ produce reassignment plan
          │  • LLM-as-judge ────────────▶ score plan quality
          │  • Arize ───────────────────▶ trace every LLM call
          └─────────────────────────────┘
                       │ 3. store resolved incident back into memory

Agents

SwarmCoordinator (coordinator_agent.py) — entry point. Implements the Agent Chat Protocol, runs as a mailbox agent (no public endpoint needed), orchestrates everything below. Address: agent1qw7awftrnyz2haxmwc7frd0u2mweelukfcueeer6lg2xcqq0mvef608jgmm
DroneAgent (drone_agent.py) — one process per drone, holds its own state (battery, position, task queue), answers status queries, accepts/rejects task assignments under a battery-safety rule. Launch many with distinct --id/--port.
Shared message schemas (messages.py) — typed uAgents Models exchanged between coordinator and drones (routed by schema digest, so both sides must match exactly).

Reasoning, memory, observability

claude_reasoning.py — builds the prompt from live fleet state + the disruption (+ recalled context), calls Claude for a structured plan, and contains the LLM-as-judge evaluator. All Claude calls are traced to Arize.
agent_memory.py — RedisVL vector index over incident embeddings (all-MiniLM-L6-v2, local, 384-dim). Stores each resolved incident; retrieves semantically similar past ones to inform new decisions.

Sponsor technology

Sponsor	How it's used	Prize track
Fetch.ai (uAgents, Agent Chat Protocol, Agentverse, ASI:One)	All agents are uAgents; coordinator is registered on Agentverse and usable directly from ASI:One; agent-to-agent messaging uses typed protocols	Fetch.ai / ASI:One
Anthropic Claude (`claude-sonnet-4-6`)	The reasoning engine that produces reassignment plans, and the LLM-as-judge that scores them	—
Redis (RedisVL + vector search)	Agent memory: incidents embedded and stored in a Redis vector index; semantic similarity search retrieves relevant past incidents as context for new decisions	Redis (Agent Memory / vector search / context retrieval)
Arize AX (OpenTelemetry + OpenInference)	Distributed tracing of every Claude call (reasoning + judge), with plan-quality evaluation scores attached as span attributes	Arize

Setup

Requires Python 3.11+.

# 1. Install dependencies
pip install -r requirements.txt

# 2. Create your secrets file from the template and fill it in
cp .env.example .env
#    Edit .env with your real ANTHROPIC_API_KEY, REDIS_URL, ARIZE_SPACE_ID,
#    ARIZE_API_KEY, and AGENTVERSE_API_TOKEN.

One-time: claim the coordinator's mailbox

The coordinator uses a mailbox so it's reachable through ASI:One without a public endpoint. The first time you run it, claim the mailbox:

Start the coordinator (./run.sh).
Open the inspector URL printed in logs/coordinator.log (https://agentverse.ai/inspect/?uri=...&address=...) in Chrome.
Sign in to Agentverse and click Connect / Create Mailbox.
Restart (./run.sh) — the Agent mailbox not found warning disappears.

Run

./run.sh

This loads secrets from .env, launches the coordinator (port 8000) and all three drones (ports 8001–8003) in the background with logs under logs/, and prints a summary of what's running.

Stop everything:

pkill -f coordinator_agent.py ; pkill -f drone_agent.py

Try it

In ASI:One (the primary workflow): find the SwarmCoordinator agent and send it a disruption, e.g. "Drone-2's battery has dropped critical, reassign its remaining tasks." You'll get back the live fleet status, a reassignment plan with rationale, and an LLM-as-judge quality score — and a 🧠 note if a similar past incident was recalled from memory.

Locally (no UI needed): chat_test_client.py simulates an ASI:One user.

python3 chat_test_client.py --scenario 1   # battery critical (wording A)
python3 chat_test_client.py --scenario 2   # battery critical (wording B — semantically matches 1)
python3 chat_test_client.py --scenario 3   # weather exclusion zone (different scenario)
python3 chat_test_client.py --message "custom disruption text"

Run scenario 1 then 2 to see semantic memory recall: scenario 2 is worded differently but recalls scenario 1 via vector similarity. Scenario 3 (weather) is correctly judged not similar and reasoned from scratch.

Repository layout

coordinator_agent.py   SwarmCoordinator: chat handler, fan-out, memory, reasoning, eval
drone_agent.py         DroneAgent: per-drone state + status/assignment protocol
messages.py            Shared typed message schemas (coordinator <-> drones)
claude_reasoning.py    Claude reasoning, LLM-as-judge, Arize tracing
agent_memory.py        RedisVL vector memory (store / retrieve similar incidents)
chat_test_client.py    Local test client (simulates an ASI:One user)
run.sh                 Launch the full stack from .env
requirements.txt       Python dependencies
.env.example           Template for secrets (copy to .env)

Roadmap

Real disruption detection (a HazardAgent monitoring battery/weather thresholds and proactively notifying the coordinator) instead of disruptions described in chat.
Live map visualization driven off the Redis incident/message log (bonus polish).

Analysis

Compare with all teams

View

Metric

Lena Munad
2
Claude Opus 4.8
1

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
HTMLIn code
PythonIn code
RedisIn code

4 of 4 appear in the indexed code.

AI coding agents

Claude CodeCommits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

65 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.