Our Vision
Autonomy is moving from single machines to teams. The missions that matter most, i.e., searching a disaster zone, mapping an unknown environment, monitoring a contested area, will be carried out by fleets of very different robots working together: lightweight drones for surveillance, larger UAVs for mapping and delivery, and humanoid, legged, and wheeled robots for moving through places built for people, not machines. These teams will have to operate where the map is incomplete, communication is intermittent, conditions change by the minute, and something is always breaking. And they will have to keep working as the mission itself evolves.
The hard part is not building any one robot. It is making a whole system out of many moving parts and being able to trust how it behaves, and then being able to change it. In practice, the ingredients of autonomy (control, planning, learning, and system integration) are still designed largely in isolation. The result is architectures that are brittle and difficult to modify: adding a new platform, swapping a sensor, or revising an objective can force engineers to re-tune the entire stack, with no guarantee that safety and performance survive the change. Autonomy that cannot evolve cannot scale.
The idea: compositionality
SCHEMA — Scalable Compositional Hierarchies for Evolvable Multi-agent Architectures — is built on the principle of compositionality. We want to guarantee how a whole system behaves directly from the way its parts are combined, rather than re-verifying everything from scratch each time. Two kinds of composition matter, and SCHEMA treats them together for the first time:
- Horizontal composition — combining many heterogeneous agents into a fleet, so that capabilities, resources, and tasks fit together across the team.
- Vertical composition — combining the layers inside a single agent, from high-level decision-making down to trajectory planning and real-time control, so that strategic goals remain feasible and safe all the way down.
Our bet is that giving both of these a common, formal language, drawing on control theory, formal methods, optimization, and learning, is what turns autonomy from something we hand-build into something we can compose, re-compose, and reason about. That language should support top-down synthesis (turning a mission specification into an architecture) and bottom-up adaptation (revising that architecture from what the system observes and where it fails), while carrying formal guarantees on safety and performance throughout.
The three themes of SCHEMA. Theme A composes heterogeneous agents horizontally into a fleet; Theme B composes the layers of a single agent's autonomy stack vertically; Theme C unifies the two, trading off fleet-level and agent-level capability.
Three themes, one framework
Our research is organized into three interdependent themes with clearly defined interfaces between them.
Composing a fleet of heterogeneous agents
How should a team be put together so the pieces fit? Theme A develops ways to model, combine, and verify fleets of very different agents, matching what each platform needs against what it provides, across shared resources and overlapping tasks. We build on ideas from categorical co-design and assume–guarantee contracts to reason about these trade-offs formally, and on uncertainty-aware optimization to keep the reasoning honest when the world is only partly known. The goal is fleet-level design and adaptation that stays interoperable and scalable as agents are added, removed, or reconfigured.
Keeping an agent consistent across its layers
Inside every agent sits a stack: decide what to do, plan how to do it, and control the body that carries it out. Theme B asks how to decompose that stack so the layers stay consistent, so that a high-level intention is actually achievable by the low-level controller, and safety is preserved end to end. The key is finding the right level of abstraction between layers: expressive enough to be useful, simple enough to reason about. We use reduced-order models, layered control architectures, and learning that refines those models online, so agents remain robust without becoming overly conservative.
Making the fleet and the agent agree
A fleet is only as good as the agents in it, and an agent only matters in the context of its team. Theme C brings horizontal and vertical composition together, so that the structure inside each agent is compatible with the structure across the fleet. This lets us reason about the whole system's optimality, how capability at the agent level trades off against capability at the fleet level, and where diversity-enabled sweet spots emerge. We test these ideas on heterogeneous teams of humanoids, quadrupeds, and UAVs operating in uncertain environments.
From ideas to demonstrations
SCHEMA is not only a theory effort. We validate the framework in simulation and in the real world, on heterogeneous fleets of humanoids, quadrupeds, and UAVs, under uncertainty and degraded conditions, i.e., the settings where brittle architectures fail. And we want the results to be used beyond the center: our work will be released as open-source toolkits, cross-platform codebases, and curated datasets, building toward an open ecosystem for compositional autonomy.
SCHEMA is supported by AFOSR and AFRL under the FY25 Compositional Optimization, Dynamical Systems and Control (CODAC) program, and brings together researchers at MIT, Caltech, UC Berkeley, and the University of Pennsylvania. Meet the team.