RocketCursor

Agentic Fluid & Thermodynamics Simulation
3DOF Flight Simulator
Final Report of Design Choices & Reasoning

Inspiration

Propulsion issues are the number one reason why rockets fail. One small mistake in an engine or fuel system can destroy the rocket, leading to lost payloads, delayed missions, and hundreds of millions of dollars in losses per year.

That is why designing these systems is so crucial. Engineers spend months analyzing and reanalyzing their fluid system designs, which is one of the core reasons rocket development can stretch on for years.

For student teams, the stakes are even higher because they are learning these systems while working around real hardware, without the money to recover from major mistakes. Without years of hands-on experience, it is easy to miss small design mistakes that can create dangerous testing conditions, damage hardware, or cause extreme injury.

What it does

RocketCursor helps engineers and student teams design rocket fluid systems by chatting with an AI. Users can describe the rocket system they want, and RocketCursor turns it into a working design with a system diagram, suggested parts, physics simulation, flow checks, and safety warnings.

It uses a database of past rocket failures and NASA technical reports to catch mistakes before they become dangerous. By reducing the time spent on diagrams, calculations, simulations, and procurement research, RocketCursor can help teams save months of development time and avoid mistakes that could cost millions of dollars.

How we built it

Anthropic

RocketCursor was built with Claude Code, which helped us develop the backend, frontend, agent loop, and simulation workflow. Claude Code made it faster to build and iterate on the system, especially while connecting the design interface, physics simulation, and AI-guided engineering workflow.

Fetch.ai

Fetch.ai is the agentic backbone of the system. ASI1 handles the reasoning: turning plain-English text into a list of requirements, generating a rocket fluid network design, and revising it based on test results.

Rather than bundling everything into one script, the system uses two separate agents:

A Designer, powered by ASI1, that proposes designs
A Simulator that runs deterministic tests and returns a pass/fail verdict

Keeping them separate means the Designer can never evaluate its own work, so the judgment stays objective and auditable. Both agents are registered on Agentverse, giving them stable identities and making the full design-test-revise loop accessible from the ASI:One chat interface or by any other agent on the network. The Fetch.ai agent demo video at https://www.youtube.com/watch?v=COVCmJ8eLdQ.

The Token Company

We built requirement-aware compression for RocketCursor’s agentic design loop. Our simulator emits full transient time-series outputs of roughly 170k tokens per iteration, which a naive agent loop would re-send to the LLM after every revision.

Instead of paraphrasing the raw output, we condition the compressor on the task’s machine-checkable requirements and preserve only the decision-relevant verdicts, exact values, and failure signals needed for the next design update.

Across 14 real iterations, this reduced 2.38M tokens to 3,065 tokens, a 99.87% reduction, while improving revision quality because the model acts on a clean engineering signal instead of raw simulator noise.

We also tested this directly with The Token Company’s tokenizer:

TTC’s bear-2 compressor only reduced raw simulator output by 0.45%
Our requirement-aware pass reduced it by 99.78%, down to 433 tokens
TTC’s compressor then reduced our verdict another 27%, from 433 to 315 tokens

The methods are complementary. To preserve engineering accuracy, we stack TTC’s hosted compressor on the static prompt prefix and use protect() fences around every critical number so values pass byte-exact through lossy compression.

The core idea is domain-agnostic and can apply to any requirement-checked time-series system.

PaleBlueDot AI

We used PaleBlueDot AI’s TokenRouter to optimize the cost and efficiency of our AI workflow by routing different LLM calls to the best model for each task. RocketCursor uses multiple models across part procurement, design creation, requirement extraction, and simulation review. TokenRouter helped us manage those model calls through one routing layer instead of hardcoding everything to a single model.

Arize

We used Arize to trace every LLM design and revision call and run LLM-as-judge soundness evaluations alongside our simulator. This helped us catch weak reasoning, unsafe suggestions, and inconsistent revisions, making RocketCursor more trustworthy and easier to debug.

Redis

We used Redis Stack to power storage and retrieval. RedisJSON and RediSearch store failure records, NASA technical reports, design history, and session state, while vector search retrieves relevant engineering context through our retrieval layer, Iris.

Browserbase

We used Browserbase to ingest live NASA and engineering sources from the web, helping us expand the technical report and failure knowledge base that grounds RocketCursor’s recommendations.

We used Browserbase a second time to ingest optimal component specifications generated by our physics agent and search a select number of component websites, including McMaster-Carr and Swagelok, to find the best-fit component. We also leveraged Browserbase’s Stagehand to automate supplier website authentication, part sourcing, and quote submission, enabling an end-to-end procurement workflow directly from RocketCursor.

Sentry

We used Sentry as a critical reliability layer for the rocket fluid-network design tool. It tracks failures across the React P&ID viewer, the FastAPI API, and the background agent loop that turns user requirements into simulator-ready propulsion designs.

This is especially important because a single user request can move through chat/voice input, spec generation, iterative design, simulation, artifact loading, and animated telemetry playback.

Sentry helps us catch where that pipeline breaks, whether it is a frontend rendering issue, a failed API call, a design-loop crash, a bad simulation artifact, or an exception inside a background revision run.

Deepgram

We used Deepgram Nova-3 to build a live voice copilot for RocketCursor that can listen to engineering conversations, transcribe them in real time, and extract the actual design feedback and deliverables.

In rocket development, some of the most useful feedback happens during design reviews, test meetings, and hardware discussions, but that context is often never recorded or turned into action.

With Deepgram, RocketCursor can capture those conversations, identify requested changes like adding valves, resizing lines, updating requirements, or checking failure modes, and automatically iterate on the P&ID and fluid system design.

This turns spoken engineering feedback into immediate design progress instead of lost context.

Challenges we ran into

One of our primary technical challenges was parsing and processing large failure reports, many of which exceeded 100 pages. Handling these documents efficiently required significant optimization, making our Token Company challenge around token compression critical to maintaining the speed and responsiveness of the system.

Another challenge involved navigating the varying user interfaces of supplier websites such as McMaster-Carr. Because these platforms did not provide separate endpoint URLs for authentication and quoting workflows, our Browserbase agents initially struggled to identify the correct navigation paths.

We addressed this by refining our prompting strategy and workflow logic to reliably guide the agents through each site's interface.

Accomplishments that we're proud of

We are particularly proud of the requirement-aware document processing pipeline we developed to analyze large engineering failure reports and simulation outputs while significantly reducing token consumption. Instead of summarizing documents generically, our system extracts the specific constraints, failure modes, pressure limits, safety margins, and validation criteria that matter for a rocket fluid system. This allowed us to preserve the engineering signal while discarding irrelevant context.

By optimizing how information was extracted and compressed, we improved both the quality and efficiency of the system. Across 14 design iterations, our compression pipeline reduced context size by more than 99%, turning millions of raw tokens into compact engineering verdicts with pass/fail checks, key metrics, and safety-relevant explanations. This made the design loop faster, cheaper, and more reliable because the model received structured engineering evidence rather than massive unfiltered documents or raw CSV outputs.

We are also proud of the end-to-end workflow we built in a limited timeframe. RocketCursor does not stop at generating text. The platform analyzes failure data, uses a multi-agent framework to propose and revise rocket fluid system designs, validates those designs with a deterministic physics simulator, and then continues into automated reporting and supplier quoting.

Bringing these components together into a cohesive system was a major accomplishment. The result is a full engineering loop: an engineer can describe a system, the AI can retrieve relevant technical knowledge, generate a structured design, test it against physics and requirements, surface failure risks, identify compatible parts, and help initiate procurement. We are proud that we built not just a demo, but a working prototype of an AI-assisted aerospace engineering workflow.

Finally, we are proud of the physics foundation underlying our design process. Modeling rocket performance involves complex calculations and engineering tradeoffs, and we invested significant effort to ensure our simulations and recommendations remained grounded in realistic physical constraints.

What we learned

One of our biggest learning experiences was using Fetch.ai to coordinate multi-agent workflows for complex engineering tasks.

Rocket fluid system design requires many dependent steps, and Fetch.ai helped us understand how specialized agents can divide that work, pass context between each other, and iteratively improve a design in a way that feels closer to how real engineering teams collaborate.

What's next for RocketCursor

Upgrade the 3DOF flight simulator to a 6DOF flight simulator with aerodynamics to simulate all effects on the rocket.
Add controls and trajectory modeling so teams can see how propulsion design choices affect stability, guidance, and flight performance.
Add test planning support so RocketCursor can turn validated designs into safer test procedures, readiness checks, and failure-aware test sequences.