-
-
Homepage
Inspiration
Waste management is not only a waste-classification problem—it is an operations problem.
A bin reaching 95% capacity can trigger a chain of decisions: Is it urgent? When will it overflow? Which vehicle is available? Which other bins should be collected on the same route? Does the operator need to approve the action? And after collection, did the action actually solve the problem?
We wanted to move beyond an AI system that simply predicts or classifies waste.
That led us to WasteOps, an autonomous AI operations agent designed to detect problems, make decisions, take action, and verify the outcome.
What WasteOps Does
WasteOps continuously processes simulated smart-bin and fleet events.
When an operational event occurs, the agent can:
- Detect a potentially critical situation.
- Analyze the severity and predicted impact.
- Retrieve relevant operational history.
- Check vehicle and crew availability.
- Generate an optimized collection plan.
- Create an operational task.
- Request human approval when appropriate.
- Assign a vehicle and execute the approved action.
- Verify whether the collection actually happened.
- Record the outcome in persistent operational memory.
The important distinction is:
Traditional chatbot: User asks → AI responds.
WasteOps: Event occurs → Agent detects → reasons → plans → calls tools → changes system state → requests approval when needed → executes → verifies → records the outcome.
This makes WasteOps an agentic workflow rather than a conversational demo.
How We Built It
WasteOps is designed around a modular agent architecture.
Agent Architecture
The system uses a central WasteOps Orchestrator together with specialized agents:
- Triage Agent — determines incident severity and recommended action.
- Route Agent — evaluates vehicle availability, capacity, priority, and collection sequence.
- Operations Agent — converts decisions into executable tasks.
- Verification Agent — checks whether the requested operation was successfully completed.
The agents interact with registered tools such as:
get_bin_status()get_fleet_status()optimize_route()create_collection_task()assign_vehicle()create_maintenance_ticket()request_human_approval()update_task_status()verify_collection()record_agent_decision()
This allows the AI to perform actions against application state rather than simply generating text.
Google Technologies
The project is built around Google's agentic ecosystem:
- Gemini for intelligent decision-making
- Google Agent Development Kit (ADK) for agent orchestration
- Google Cloud Run for deployment
- Firestore for persistent operational state and memory
- Pub/Sub for event-driven asynchronous processing
The architecture separates the AI decision layer from the tools, database, event system, and frontend so that the system can evolve into a production-grade agent platform.
Autonomous Workflow
A typical event looks like this:
Smart-bin event
↓
Event processing
↓
WasteOps Orchestrator
↓
Triage Agent
↓
Historical context + fleet state
↓
Route Agent
↓
Operations Agent
↓
Human approval (when required)
↓
Collection task
↓
Execution
↓
Verification Agent
↓
Persistent state + audit log
For example, if a bin reaches 94% capacity and its historical fill rate indicates that it may overflow soon, WasteOps can identify the risk, check the available fleet, select an appropriate vehicle, generate a collection task, and request approval.
Once approved, the task moves into execution. The system then simulates the collection and verifies that the bin's fill level actually decreases.
If verification fails, WasteOps does not simply mark the task as successful. It can create a follow-up action or escalate the issue.
Asynchronous Operation
A major goal was to demonstrate that an agent does not need to wait for a user message before doing useful work.
WasteOps supports an event-driven architecture:
Event → Pub/Sub → Agent Processing → Tool Execution → Firestore → Dashboard
The application also includes a simulator that can generate individual incidents or a city-wide operational surge.
The City-Wide Surge scenario creates multiple simultaneous incidents, forcing the system to prioritize problems, consider fleet constraints, create tasks, identify conflicts, and determine which actions require human approval.
Human-in-the-Loop
Autonomy does not mean removing humans from every decision.
WasteOps uses a human approval layer for actions that may require operational authorization.
The manager can:
- Approve
- Reject
- Modify
an agent-generated task.
The decision is then recorded as part of the operational history.
This creates a practical balance between autonomous execution and human oversight.
Safety and Reliability
We also designed the system to avoid blindly trusting incoming operational data.
The system validates sensor inputs and can identify anomalies such as impossible fill levels or unavailable vehicles.
External event data is treated as untrusted input so that an event cannot override the agent's system instructions or invoke arbitrary operations.
Only registered tools can modify operational state.
Agent actions are also recorded in an audit trail containing the event, action, target, result, and timestamp.
What We Learned
The biggest lesson was that building an agent is fundamentally different from building a chatbot.
The intelligence of an agent is not just the quality of its generated response.
It comes from the complete loop:
Perception → Decision → Planning → Action → Verification
We also learned that deterministic components are valuable alongside AI.
For example, route calculations and capacity constraints do not need to be hallucinated by a language model. The agent can use deterministic algorithms and tools for those operations while Gemini handles higher-level decisions and orchestration.
This separation makes the system more reliable and easier to debug.
Challenges
Making the system genuinely agentic
The biggest challenge was avoiding the temptation to make everything a chatbot response.
We solved this by giving the agent real tools that read and modify operational state.
Handling failures
Real operations are unpredictable.
Vehicles can become unavailable, sensors can report incorrect values, and collections can fail.
We therefore designed explicit failure paths instead of assuming every agent action succeeds.
Balancing autonomy and control
Fully autonomous execution is not appropriate for every operational decision.
The human approval workflow allows WasteOps to remain autonomous while keeping humans in control of higher-impact actions.
Keeping the architecture practical
We wanted the project to demonstrate sophisticated agent behavior without introducing unnecessary infrastructure.
The system therefore uses lightweight serverless Google Cloud services and separates production cloud adapters from local development fallbacks.
Why WasteOps?
WasteOps demonstrates a practical transition from:
AI that answers questions
to
AI that operates systems.
Instead of asking a manager to manually monitor dozens of waste-management signals, WasteOps continuously watches the operational environment, determines what requires attention, takes appropriate action, and verifies the result.
The long-term vision is to extend WasteOps from simulated smart bins into real municipal infrastructure, integrating IoT sensors, collection vehicles, maintenance systems, and city-level operational data.
For this hackathon, our focus is simple:
Give an AI agent a real operational problem—and let it actually do the work.
Built With
- ai-agents
- autonomous-agents
- cloud-run
- event-driven-architecture
- fastapi
- firestore
- gemini
- generative-ai
- google-adk
- google-ai-studio
- google-cloud
- iot
- machine
- multi-agent-systems
- pub/sub
- python
- react
- smart-waste-management
- typescript
Log in or sign up for Devpost to join the conversation.