Faster and Cheaper: Building Scalable Autonomy for Complex Missions

Developing autonomy software for defense and complex applications has traditionally been a monumental effort—one that demands not only time and resources but also a team of highly specialized experts. At Shield AI, we’ve focused on transforming this model by building re-usable and scalable autonomy that minimizes the need for constant rewrites, accelerates development time, and leverages automation to improve testing and validation. This blog explores some of the core challenges in traditional autonomy development and outlines a five-step strategy to building more versatile, robust solutions. 

The Old Way: Time Consuming and Expensive 

Historically, developing autonomy for a new platform or mission set meant starting from scratch. This process required a large team of Ph.D.-level experts and software engineers, often working with open-source tools like the Robot Operating System (ROS) to piece together various components. While ROS has served as a valuable resource for prototyping, its limitations become apparent when moving to high-stakes, mission-critical applications. Here are some challenges commonly faced in traditional autonomy development: 

1. Extensive Expertise Requirement: The old approach requires a large, costly team of experts to build and integrate autonomy. Building the necessary components, adapting them to new platforms, and troubleshooting integration issues consume significant resources.
2. Slow Development of New Capabilities: Developing new capabilities, e.g., mission-specific behaviors or adding a new sensor for sensor fusion can take months, if not years. Each time a new capability is needed, significant amounts of code often have to be written from scratch and adapted to the specific nuances of the platform / hardware.
3. Lack of Scalable Testing and Validation: Testing and validation are usually done on a developer’s machine or with custom, often unreliable scripts. This setup is challenging to scale, and testing can be inconsistent, potentially missing critical test cases.
4. Hard to Reuse Code: With every new program or platform, autonomy software often has to be refactored or rewritten, making it hard to reuse code effectively across different applications.
5. Reliance on Open-Source Support: Many developers rely on open-source communities for support, which can slow down troubleshooting and limit the ability to make quick, high-quality adjustments.
   
   

Certifiable autonomy is critical for safety in defense and military aviation. However, ROS was not designed to meet aerospace-grade certification standards. Although open-source initiatives like Space ROS are working to address this gap, these efforts are still in their infancy. 

In sharp contrast to ROS, the Hivemind SDK and EdgeOS middleware are purpose-built with certifiability as a core priority. Moreover, we are committed to supporting our customers in achieving certification for their platforms, ensuring compliance and reliability. 

A New Approach to Autonomy Development

At Shield AI, we’re taking a different approach. Instead of building custom code from the ground up for each new program, we’ve designed an approach that allows for scalable, reusable autonomy. This shift brings multiple benefits, including faster deployment, lower resource requirements, and enhanced flexibility. Here’s how our new approach addresses the key pain points in autonomy development:

1. Smaller, More Focused Teams: By using a more structured and reusable autonomy framework, a smaller team of software engineers, supported by a few Ph.D.-level experts, can accomplish what used to require a much larger team of subject matter experts. This structure makes it feasible to deploy autonomy quickly without extensive staffing.
2. Reusable, Extensible Code: Our autonomy software is built to be reused across multiple platforms and programs. Instead of rewriting code for each application, engineers can extend existing code to add new capabilities, e.g., tasks, behaviors, actions, sensors etc. making the process faster and more efficient.
3. Automated, Scalable Testing in the Cloud: Testing and validation can be performed at scale, thanks to cloud-based automation. This setup ensures that autonomy software is reliable and capable of handling complex scenarios without requiring developers to test each case manually on a local machine.
4. Standardized, Modular Interfaces: We prioritize standardizing interfaces, making it easier to integrate autonomy software with new sensors, payloads, and platforms. By supporting industry-standard protocols like STANAG4586 and MAVLink, our software can adapt to various platform configurations and communications requirements seamlessly.
5. Enterprise-Grade Support and Tools: Developers working with our framework have access to advanced, reliable tools designed specifically for large-scale autonomy applications, along with a dedicated Hivemind support team that ensures quick issue resolution and stable operation.

Strategy for Efficient Autonomy Development

Our approach to building autonomy prioritizes scalability and efficiency, allowing teams to develop capabilities faster and at a lower cost. Instead of relying on large, specialized teams, we focus on smaller groups of engineers who can leverage a robust, reusable autonomy framework. This approach brings together a few core principles:

• Develop Reusable Code: Reusability is at the heart of our software design. By creating a modular codebase that can adapt to different programs, we minimize the need for rewrites and speed up the customization process for new missions.
• Focus on Extensibility: Rather than writing new code for every capability, we designed our core software to be extensible. This means engineers can add new functionalities without reworking the foundational code, making it easier to roll out new features across platforms.

• Leverage Cloud-Based Automation: Cloud-based testing and validation allow for rapid scaling, which means we can thoroughly test autonomy software without being limited by individual developer machines. This shift reduces manual testing time and ensures higher reliability.

We demonstrated this during our work flying autonomy on the MQM-178 Firejet, a Group 4 uncrewed jet. It took just three months from the start of the project to the first flight—a significant improvement compared to the 12+ months required for similar projects in the past. Additionally, this effort only required 10 personnel, compared to the 20+ typically needed for previous platforms. By equipping small, focused teams of engineers with scalable tools and a reusable autonomy framework, we’ve been able to dramatically reduce both time and resource requirements.

Building a Reusable Autonomy Stack

One of the biggest challenges in autonomy development is the tendency to rewrite code for each new program or platform. With our modular autonomy stack, we’ve minimized this need for rewrites, making it easier to deploy autonomy across different vehicles and missions. We do this by providing core autonomy libraries across Perception, Cognition, and Action wrapped into reusable components (blocks) that can be adapted as needed. For example, a developer could replace an existing block with an entirely custom-built block as long as they respect the block’s input/output interfaces. By focusing on a core set of functions, we ensure that engineers can add specialized capabilities without needing to re-engineer the foundational code.

Extending Autonomy with Ease

Traditional autonomy development often means months of refactoring and rewriting parts of code to get new capabilities working. Our approach, however, is to make the core software extensible. This flexibility allows engineers to add new capabilities with minimal changes to the underlying code, meaning faster deployment and greater adaptability in rapidly changing environments.

An example of this is adding new tasks and behaviors to the AI Pilot in order to address a new mission or scenario. With the Hivemind Pilot, a developer can define a re-usable set of tasks and behaviors that can be carried across autonomy programs and platforms without having to write that code each time.

Automating Testing and Standardizing Interfaces

Testing autonomy software is inherently complex, especially when each case must be evaluated for reliability and performance. With our scalable cloud-based testing tools, we can automate this process, ensuring comprehensive testing while saving valuable developer time.

The Hivemind SDK simplifies autonomy development with a point-and-click tool for creating simulation scenarios. Hivemind leverages Kubernetes to enable developers to run hundreds or thousands of simulations simultaneously across multiple cloud instances with no need to implement custom data pipelines or orchestration tools.

A New Era of Scalable, Reliable Autonomy

At Shield AI, our approach to autonomy development allows for faster deployment, improved flexibility, and greater reusability. By building modular, extensible software with standardized interfaces and automated testing, we’re making it possible for a small team to deliver sophisticated autonomy on a large scale. This new model of autonomy development not only drives down costs but also enables rapid response to new challenges, ensuring that autonomous systems can meet the demanding requirements of defense and commercial applications alike.

About the Author

Saurav Agarwal is the Director of Customer Engagement (Customer Success & Applications Engineering) at Shield AI, where he leads global efforts to ensure Hivemind customers achieve mission success. With over a decade of experience in AI, robotics, SaaS, and industrial automation, Saurav is a seasoned business executive and two-time startup founder. Previously, he founded SIERA.AI, where he raised $7M in venture capital, built a team of 30 across two continents, and launched successful AI and robotics products with over 60 enterprise customers. Saurav holds a Ph.D. in Robotics from Texas A&M University, specializing in autonomous navigation. He also writes The Persistent Founder, a newsletter offering strategies and insights to help founders scale their businesses. In his free time, he is learning to fly (currently in the Cessna Skyhawk) and enjoys playing guitar.