ScalePilot

• 

  Workflow Brainstormed

• 

  Initial Project goal （Breakdown）

• 

  Agent profile on Agentverse

Inspiration

In many chemical engineering and materials research projects, there is a difficult gap between a successful lab-scale recipe and a practical pilot-scale process. Researchers may know the chemistry, reaction conditions, product requirements, and major concerns, but turning that information into equipment choices is still slow and messy.

Early process scale-up requires engineers to think about reactors, separation methods, drying equipment, material compatibility, pressure and temperature limits, contamination control, supplier communication, and rough cost ranges. For students, researchers, and early-stage technical teams, this information is often scattered across textbooks, supplier websites, engineering experience, and informal notes.

ScalePilot was inspired by this gap. I wanted to build a transparent AI-assisted workflow that helps users move from a lab-scale process brief toward a structured preliminary equipment recommendation. The goal is not to replace qualified process engineers, but to make early process scale-up easier to understand, organize, and communicate.

What it does

ScalePilot is an ASI process equipment selection agent for early-stage chemical process scale-up.

Given a structured lab-scale process brief, ScalePilot runs a modular engineering workflow that:

• Builds a preliminary process basis
• Identifies the target product, operating conditions, scale-up factor, and missing data
• Decomposes the process into major unit operations
• Searches a mock equipment database for possible equipment candidates
• Screens candidates based on temperature, pressure, volume, material compatibility, and contamination concerns
• Explains why each equipment candidate is accepted or rejected
• Matches recommended equipment with mock suppliers
• Estimates a rough CAPEX range using mock data
• Generates a supplier inquiry draft that users could later turn into an RFQ-style message

The demo case focuses on scaling a lab-scale hydrothermal synthesis process for MnO₂ nanoparticle powder used in aqueous zinc-ion battery cathodes. The system produces both a structured JSON output and a human-readable Markdown report.

ScalePilot is also wrapped as a Fetch.ai uAgent and can be reached through ASI using the chat protocol. Users can interact with it conversationally by asking prompts like “analyze,” “why the Teflon-lined autoclave?”, or “rfq.” The deterministic engineering workflow remains the source of truth, while the optional LLM layer only makes the response more conversational.

How I built it

I built ScalePilot with Claude Code and Codex as a local-first Python MVP, then wrapped the working workflow into an ASI Fetch.ai uAgent. This helped me keep the core engineering logic simple, testable, and transparent while also making the project usable as a conversational agent.

The workflow is organized into modular components:

• process_basis.py extracts the product, scale, reaction conditions, priorities, and missing data.
• unit_decomposer.py breaks the process into unit operations such as precursor preparation, hydrothermal reaction, cooling, separation, washing, drying, and powder collection.
• equipment_selector.py searches a mock equipment database for candidates that match each unit operation.
• engineering_reviewer.py screens and ranks equipment candidates using engineering constraints.
• supplier_matcher.py connects recommended equipment to mock supplier options and rough cost ranges.
• rfq_generator.py creates a supplier inquiry draft based on the selected equipment and operating requirements.
• main.py orchestrates the local workflow and generates the final output files.
• agent.py wraps the workflow as a uAgent so users can interact with ScalePilot through ASI.

The MVP uses structured JSON input files and mock equipment and supplier databases. I intentionally avoided hidden APIs, real procurement actions, and external dependencies in the core workflow so that the project could run locally and be easy to explain during a hackathon demo.

Challenges I ran into

One major challenge was scope control. Process scale-up is a huge engineering problem, and it would be easy to overbuild the project by adding real supplier search, ASPEN integration, web apps, complex multi-agent orchestration, or detailed process simulation too early. I had to keep reminding myself that the first goal was a clean, runnable MVP.

Another challenge was translating engineering reasoning into modular software logic. Equipment selection is not just keyword matching. The system needs to consider temperature, pressure, working volume, material compatibility, contamination risk, phase suitability, and unresolved assumptions. I had to design the workflow so that the reasoning was clear enough for users to inspect.

A later challenge was adapting the local workflow into an agent that could be used through ASI. I had to make sure the conversational layer did not replace the engineering logic or invent unsupported data. The final design keeps the deterministic workflow as the source of truth and uses the LLM only to explain the results conversationally.

I also had to be careful about ethical and safety boundaries. ScalePilot should not pretend to produce a certified process design. The report includes limitations and clearly states that the output is preliminary and requires review by a qualified process engineer before procurement or implementation.

Finally, I had to work in an unfamiliar software development environment under a very limited hackathon timeline and limited API credit. This included learning how to use the terminal, structure a Python project, debug the workflow, publish an actual project on GitHub, and connect an agent to Agentverse and ASI.

Accomplishments that I'm proud of

I am proud that ScalePilot runs as a complete local workflow from a sample process input to final output files. The system generates both a structured JSON result and a readable Markdown report that explains the process summary, unit operations, equipment recommendations, screening reasoning, supplier matches, rough CAPEX, and next steps.

I am also proud that ScalePilot is now wrapped as a conversational uAgent and can be used through ASI. This turns the project from a local command-line MVP into an interactive agent demo where users can ask follow-up questions, request reasoning, and generate a supplier inquiry draft.

I am especially proud of the transparency of the recommendation logic. Instead of only giving a final answer, ScalePilot shows accepted candidates, rejected candidates, reasoning, missing data, and unresolved risks. This makes the system more useful as an educational and decision-support tool.

On a personal level, I am proud of what I accomplished in the past 24 hours. This was my first time seriously using the terminal, my first time publishing an actual project on GitHub, and my first time pushing myself to build a software project from 0 to 1 in an unfamiliar field. As someone with a chemical engineering background, this hackathon challenged me to step outside my comfort zone and turn an engineering idea into a runnable AI agent prototype.

Most importantly, I built something that connects real chemical engineering thinking with an AI agent workflow in a practical and explainable way.

What I learned

I learned that building an AI engineering assistant starts with designing a good workflow, not just adding an LLM or agent layer. Before a system can become a useful agent, it needs clear inputs, outputs, responsibilities, assumptions, and boundaries.

I also learned how important transparency is in technical AI tools. In engineering contexts, users need to know why a recommendation was made, what assumptions were used, and what risks remain. A confident but unexplained answer is not enough.

From the software side, I learned how to structure a local MVP so that it can later be adapted into a multi-agent system. Keeping the logic modular made the project easier to debug, explain, and extend.

From the engineering side, I learned how many decisions are involved even in a “simple” early scale-up problem: equipment type, operating limits, contamination control, product handling, supplier questions, cost ranges, and missing process data all matter.

More broadly, I learned that AI can be a strong boost for engineering fields beyond computer science. As engineers increasingly collaborate with software engineers and AI systems, I believe we should also learn to adapt AI tools ourselves. This helps us better understand how this technology can change future engineering work, and this hackathon was my way of pushing myself to start that process.

What's next for ScalePilot

ScalePilot is now wrapped as a Fetch.ai uAgent and can be reached through ASI as a conversational manager agent. The next step is to move from a single manager agent to a true multi-agent workflow, where specialist agents handle reactor selection, solid-liquid separation, drying, supplier matching, and supplier inquiry drafting.

Future versions could also add human-in-the-loop equipment selection, more process examples beyond MnO₂ nanoparticle synthesis, support for less-structured user inputs, curated real equipment and supplier databases, improved cost estimation, and stronger privacy controls for proprietary process data.

Long term, ScalePilot could become a transparent AI co-pilot for early process scale-up, helping researchers and engineers move from lab chemistry to practical process design faster, while keeping human engineering judgment at the center.

Built With

• agentverse
• claudecode
• codex
• fetch.ai
• python