OopsRoverOps

Inspiration

The idea started with a simple question. What if anyone could command a rover mission the same way mission control speaks, using natural language instead of writing code or controlling movement step by step. The goal was to build a system where a rover could take a plain English instruction such as “Navigate to coordinate 5,9 then return to base” and the system would figure out the rest. Planning, navigation, safety checks, execution, and reporting. That curiosity led to building OopsRoverOps. Instead of a chatbot, this is a real autonomous decision making system. The rover makes movement decisions, avoids obstacles, and completes the mission independently.

What it does

The system takes that one sentence and turns it into a complete mission lifecycle: planning, safe autonomous execution, real-time monitoring, and a downloadable mission report at the end. The autonomy is powered by cognitive agents. Each agent uses an LLM through the OpenRouter API, which lets the rover reason about goals instead of following a hardcoded script. The Planner agent reads the user’s instruction and converts it into a structured mission plan in the form of clear steps and conditions. The Rover agent then thinks through movement on a two dimensional grid. It decides what action to take next based on context, current state, and the mission plan. The Safety agent reviews every intended action before execution to make sure it is allowed, safe, and logically correct. If an action would take the rover into an invalid coordinate or through an obstacle, the Safety agent blocks that move and forces the Rover agent to think again. When the mission finishes, the Reporter agent analyzes the entire event history and automatically generates a complete PDF mission report that includes the plan, the path taken, timestamps, reasoning logs, and mission outcome. The frontend shows the autonomy happening in real time. The dashboard streams live rover movement and decision making through WebSockets, so the judges are able to see the rover think, adjust, and execute. The result is a rover that reasons about a mission instead of following a script.This is not a demo of a chatbot. This is an autonomous system that thinks, validates, and completes missions.

How we built it

We used LangGraph to orchestrate multiple AI agents through state transitions. FastAPI powers the backend and exposes endpoints for mission creation, planning, and execution. WebSockets broadcast live mission updates to the frontend. The frontend is built with React and shows rover movement on a grid while streaming agent decisions as they happen.The frontend is deployed on Vercel, which automatically builds and publishes the latest production version directly from the main branch of the GitHub repository. Supabase is used as the backend platform where server logic and project configuration are managed. All environment variables and deployment settings are stored securely through GitHub and Vercel, giving us a simple and repeatable deployment pipeline.

Challenges we ran into

Several challenges shaped the final architecture.

Language model hallucination produced invalid coordinates. We solved this by enforcing strict validation and denying movement until validated by the Safety Agent.
Movement loops occurred during return to base. We solved this with state machine constraints in LangGraph to prevent repeated states.

Accomplishments that we're proud of

We successfully built an autonomous rover system that can take a plain English instruction and complete an entire mission without predefined scripts or manual intervention. The rover plans, reasons, validates, corrects itself, and generates a complete mission report. We are proud that the system demonstrates real autonomy rather than simple automation. The AI agents think through the mission and handle uncertainty instead of executing hardcoded paths. Watching the rover interpret a sentence, move intelligently on the grid, avoid unsafe decisions, and finish with a structured mission report was proof that the architecture works end to end.

What we learned

We learned that autonomy is not about writing more logic. It is about arranging intelligent components that handle uncertainty and collaborate. LangGraph taught us how to design agent based systems using state control instead of prompt stacking. We learned how to build real time systems using WebSockets, how to manage concurrency, and how to enforce safety checks so that the rover does not get stuck in loops. We also learned how to design fallbacks so that the system remains reliable even when an AI response is incomplete. This project forced us to treat AI as a component inside a system rather than as a single response generator.

What's next for OopsRoverOps

The next step is to move from a simulated environment to real robotics. We want this same agent architecture to control an actual rover, where a user speaks a mission and the rover executes it in the physical world. We also plan to expand the system to support multiple rovers working together, more complex mission goals, and contextual awareness from external data sources. The long term vision is to create a platform where autonomous agents handle the planning and decision making, so a user can command robotics without needing to understand pathfinding, safety logic, or mission sequencing.