Contents

robotics · active

virtual_track — a config-composed spine for multi-agent racing

The mocap-based autonomy architecture I built at CONLab for multi-agent RC-car research — rebuilt as a ROS 2 platform where an experiment is a configuration over orthogonal topology axes, never a fork.

The original stack's deep flaw was that every new experiment became a new copy of the code. The rebuild's whole idea: an experiment is a configuration over orthogonal topology axes — information, deployment, heterogeneity — running one codebase, never a branch, worktree, or fork.

Work in progressLive, but still being revised — the writing, diagrams, and data figures are all actively being critiqued and improved.

Role
Sole architect & author — I designed and built the virtual_track infrastructure at CONLab (Tyler Summers Lab, UT Dallas); both the original and the clean-room ROS 2 rebuild are mine alone.
When
CONLab (multi-year original ROS 1 platform) · v2 clean-room rebuild 2026-06 – present
  • VT0–VT4 + capstonesDeployment spine landed
  • 4NominalMPC solver backends
  • 29/29 greenconlab_interfaces contract tests
  • 3Config axes per experiment
  • VT5 — hardwareNext rung

The original — the platform I built across my bachelor’s

At CONLab (the Tyler Summers Lab at UT Dallas) I led the software architecture for our autonomous RC cars — COMO and SuperCOMO — plus the groundwork for flying the same experiments on Crazyflie drones. This is the work of my bachelor’s years, and it’s a story in its own right: my way into robotics as hardware and experimental systems, and into control and motion-planning as the science running on top. The infrastructure underneath all of it was virtual_track — load a track, localize a car on it with motion capture, run planning and control, drive the vehicle. Single agent first; multi-agent and heterogeneous fleets on top.

It came together the way research systems do — one capability at a time, each earning the next:

flowchart LR
  M1["integration<br/>como_tracks · OptiTrack mocap · como/<br/>→ PID lap control at high speed"]
  M1 --> M2["track variety<br/>post-run analytics ·<br/>dual-lane · figure-8"]
  M2 --> M3["estimation + breadth<br/>velocity estimator · longitudinal PID ·<br/>centralized + decentralized · lane changing"]
  M3 --> M4["Nominal MPC<br/>controller"]
  M4 --> M5["final semester<br/>architecture hardening ·<br/>multi-agent · original DR-CVaR"]
  classDef orig fill:#edece7,stroke:#8a857c,color:#2a2824;
  class M1,M2,M3,M4,M5 orig;

The spine started as an integration — wiring the como_tracks/ module, the OptiTrack motion-capture system, and the como/ vehicle repo into one working deployment: PID lap control at high speed on the virtual track. From there it grew. More track variety (post-run data analytics, a dual-lane track, figure-8s); then a better velocity estimator for longitudinal PID and the first split into centralized and decentralized control with initial lane changing; then the Nominal MPC controller. My final semester went into hardening the virtual_track architecture itself, pushing multi-agent scenarios, and standing up the original DR-CVaR safety filter. That platform was not a throwaway — it carried the lab’s research and produced results, and it proved the core loop — load a track, localize, plan, control, drive — was the right spine to build on.

The physical platform the whole project targets: two COMO cars on the lab floor. There is no painted track on the ground — the track is virtual, defined by overhead motion capture and projected onto the vehicles. That premise, “the track is virtual,” is the name of the whole stack.

Why I rebuilt it

The stack worked, and it had one deep structural problem that I only fully named years later, rebuilding it: every new experiment tended to become a new copy of the code. A centralized run and a decentralized run were different launch trees. “Ego sees the opponent” and “ego is blind to the opponent” were different code paths. Sim and hardware diverged. The legacy base_virtual_track.py did four jobs — track loading, pose I/O, velocity estimation, and control — in a single monolithic ROS 1 loop, with gains hardcoded inline (motor = 7.75, a vrpn_client_node/COMO4/pose topic baked into the source). To change the experiment you changed the program. That is how a research codebase accretes branches, worktrees, and forks until nobody can run last year’s result.

So as I take on new projects now, I chose to rebuild virtual_track on a foundation that can carry them: a modern ROS 2 stack, current with the Python / C++ / Rust tooling I now build on, and shaped for future projects and collaborations rather than one lab’s immediate experiment. The concrete goal was still lab-facing — ship “an experiment the lab can run and validate without me present” — but the real design question wasn’t “which DDS” or “which solver.” It was: can an experiment be a configuration over one stable codebase, rather than a new copy of it?

The idea — an experiment is a point in a product of orthogonal axes

The organizing principle of virtual_track v2 is that a multi-agent experiment decomposes into a small number of independent configuration axes, and the architecture’s whole job is to let each be set separately while running the same code:

  • Information topology — per agent, what does this agent know? Self-only, sensed peers, a coordinator’s plan, or full state. This varies per agent within a single run — and it is where the science lives. The lab’s canonical case is DR-CVaR overtake-and-merge: a coordinator-informed ego that knows the opponent, racing a local-only decentralized opponent that doesn’t know the ego. Asymmetric information is the experiment, not an accident of wiring.
  • Deployment topology — where does each node run? One process on one DDS graph (simulation) or N processes across machines and ECUs (hardware). QoS and discovery live here. Crucially, deployment must be invisible to node and algorithm code: the same information topology runs co-located or distributed with only a launch-layer change.
  • Agent heterogeneity — what kind of agent? An SE(2) ground car and an SE(3) drone are two agents honoring one contract seam, manifold as config.

These axes are orthogonal. A DR-CVaR mixed-information run should be expressible whether it executes in a sim on my laptop or split across two cars over Wi-Fi, by editing one config block. The failure mode I was designing against was the one that had quietly cost the lab years: a new experiment must never be a new branch.

The seam that makes this mechanically possible is a thin, versioned contract package — conlab_interfaces — that mirrors the interfaces-linchpin pattern I use in my other ROS 2 stack. It is the stable boundary that lets me hand the lab a runnable module: shared message shapes and base classes (BasePlanner, BaseController, BaseSafetyFilter, BaseCoordinator, BaseStateEstimator), with the algorithms bound behind them.

How it’s structured — four shells and a contract

The stack is layered so that the research code never touches ROS or hardware:

  • Shell 1 — pure algorithms. Controllers, planners, estimators, safety filters. Zero ROS imports, config-only I/O, no hardcoded paths. This is where the thesis-relevant work lives — and where I can unit-test control behavior on a Mac with no simulator at all.
  • Shell 2 — simulation wrappers and the vehicle model.
  • Shell 3 — ROS 2 integration. Deliberately thin nodes (77–209 lines) that bind Shell-1 classes through the contract. A node is a wrapper, not a rewrite.
  • Shell 4 — hardware bridge. Per-platform deploy shells, aarch64 CI, real ECUs. This is VT5, and it is next.
flowchart TB
  subgraph S4["Shell 4 — hardware bridge"]
    H["per-platform deploy · aarch64 CI · real ECUs<br/>— VT5, the next rung —"]
  end
  subgraph S3["Shell 3 — ROS 2 integration"]
    N["thin nodes, 77–209 lines: bind Shell-1 classes<br/>through the contract — a wrapper, not a rewrite"]
  end
  subgraph S2["Shell 2 — simulation"]
    SM["f1tenth_gym wrappers · vehicle model"]
  end
  subgraph S1["Shell 1 — pure algorithms"]
    A["BasePlanner · BaseController · BaseStateEstimator · BaseSafetyFilter<br/>— zero ROS imports · unit-testable on a Mac —"]
  end
  S4 --> S3 --> S2 --> S1
  IFACE[["conlab_interfaces — the contract seam<br/>(msg shapes + base classes)"]]
  IFACE -.->|binds| S3
  IFACE -.->|defines| S1
  classDef algo fill:#ffe6d5,stroke:#ff5400,stroke-width:2px,color:#7a2e00;
  classDef lib fill:#edece7,stroke:#8a857c,color:#2a2824;
  class A algo;
  class IFACE lib;

virtual_track v2 itself holds no track geometry — it loads a Track or Road from tracklib (a library I spun out for exactly this reuse) and queries it. This is one of the clearest places the rebuild pays off: the original platform recorded a single track from motion capture and baked it into the server; the rebuilt pipeline treats geometry as a reusable library — ovals, figure-8s, multi-lane roads, and multi-junction graphs, generated or loaded, never hardcoded.

Left: a single oval track recorded from OptiTrack in July 2023, the driven trajectory in magenta over a grey reference, from the original platform. Right: a grid of tracklib scenarios — an oval (L0 Track), a self-intersecting figure-eight, a two-lane road (L1 Road), and an X-intersection (L2 TrackGraph) — as a reusable library.

Left: the original platform’s one track, recorded from mocap and baked into the server. Right: the same geometry role, rebuilt as tracklib — Track / Road / TrackGraph as canonical, reusable, generatable geometry rather than a hardcoded array.

The core control seam is a single pattern the whole platform is built around:

flowchart LR
  T[("Track / Road<br/>tracklib")] --> L["localize pose<br/>(mocap)"]
  L --> P["project onto track<br/>→ waypoints_ahead"]
  P --> PL["BasePlanner"] --> C["BaseController"] --> SF["BaseSafetyFilter"]
  SF --> CMD["command → drive"] --> R[("record<br/>MCAP")]
  classDef lib fill:#edece7,stroke:#8a857c,color:#2a2824;
  class T,R lib;

The elegant consequence: because per-agent planning, control, and safety run in each agent’s own namespace, and centralized coordination (BaseCoordinator) is an optional layer on top, the architecture is topology-agnostic by construction. Fully centralized, decentralized-with-global- sensing, and fully isolated are the same code with different visibility config — not three stacks.

Three panels sharing the same two-agent node chains. Centralized: a BaseCoordinator feeds plans to car0 and car1. Decentralized with sensing: car0 and car1 sense each other directly, no coordinator. Isolated: two agents with no information edges. A config line under each panel reads plan_source: coordinator, sees: [peers], and sees: [ ].

The information-topology axis, made concrete. Each panel is the same node code bound through the same conlab_interfaces contract; only each agent’s information block changes — plan_source: coordinator vs sees: [peers] vs sees: [ ]. Three runs, one codebase, no fork.

What shipped — VT0 through VT4, plus capstones

I sequenced the rebuild as a spine of independently shippable milestones, Mac-native for the build and test loop with a Docker parity net for the runtime (macOS has real ROS 2 DDS and RT-loop friction that I’d already paid down in my other stack). VT0 through VT4 have all landed:

flowchart LR
  VT0["VT0<br/>pixi / ROS 2<br/>Jazzy env"] --> VT1["VT1<br/>first Shell-3 wrapper<br/>· toolchain probe"]
  VT1 --> VT2["VT2<br/>single-agent SE(2) loop<br/>+ BaseStateEstimator"]
  VT2 --> VT25["VT2.5<br/>ego + scripted obstacle<br/>· DR-CVaR acts"]
  VT25 --> VT3["VT3<br/>real OptiTrack mocap<br/>+ namespace grammar"]
  VT3 --> VT4["VT4<br/>BaseCoordinator<br/>· N-agent mixed topology"]
  VT4 -. next .-> VT5["VT5<br/>hardware bridge"]
  CAP["capstones<br/>multi-agent DDS demo · overtake-and-merge"] -.-> VT4
  classDef done fill:#edece7,stroke:#8a857c,color:#2a2824;
  classDef next fill:#ffe6d5,stroke:#ff5400,stroke-width:2px,color:#7a2e00;
  class VT0,VT1,VT2,VT25,VT3,VT4,CAP done;
  class VT5 next;
  • VT0 — conlab’s own reproducible RoboStack/pixi ROS 2 Jazzy environment.
  • VT1 — first Shell-3 wrapper as a toolchain probe: a ROS 2 node around the DR-CVaR safety filter over real wire types, proving the macOS/Docker toolchain end-to-end. (Honestly scoped: with one agent the filter has no obstacle, so this validated bytes, not behavior.)
  • VT2 — the spine’s heartbeat: the single-agent SE(2) loop as a ROS 2 node graph, synthetic mocap → project → plan → control → drive f1tenth_gym → MCAP, fully Mac-local. This is also where BaseStateEstimator landed (mocap gives pose, not velocity).
  • VT2.5 — ego plus a synthetic scripted obstacle, so the DR-CVaR safety filter first does its job — and the home for the legacy golden-case regression, ported to validate the clean-room rewrite against the original.
  • VT3 — real OptiTrack mocap and the per-agent /<agent_id>/… namespace grammar, swapped in behind the telemetry adapter so the VT2 logic never changed.
  • VT4 — the BaseCoordinator over N a-priori-known agents with a global coordinator namespace; real N-agent, real mocap, mixed centralized/decentralized topology.

On top of the spine, the capstones landed: a visual multi-agent DDS demo and an overtake-and-merge maneuver in the planner (2026-07-01). Alongside, NominalMPC now runs four solver backends (casadi/ipopt, cvxpy, acados, and a dependency-free stub) against validated PID/pure-pursuit baselines — every experiment logs the baseline it was compared against.

The clearest single view of the pipeline doing its job is the DR-CVaR safety layer overtaking a slower car in-lane. Everything is held fixed — same track, same obstacle, same filter, same speed — and only the ego’s behavior changes: a naive ego that holds its centerline reference collides head-on, while the explicit overtake state (FOLLOW → OVERTAKE → MERGE), guarded by the distributionally-robust filter, bows around and clears. The figure is drawn on a real run, with the filter’s own separating halfspace, safe side, and 1σ obstacle-ambiguity set rendered at the decisive instant:

Two panels on the same oval track. Left: a naive ego holding the centerline collides with the obstacle at 0.00 m. Right: the guarded ego runs an overtake state and the DR-CVaR filter guards the bow, clearing the obstacle by 0.29 m, with the filter's separating halfspace and safe-side shading drawn at closest approach.

Naive vs. guarded overtake on conlab virtual_track v2 (f1tenth_gym plant, car-like actuation). Graded on the oriented-footprint gap between the 0.60 × 0.30 m bodies — not the padding disc. The DR-CVaR guard roughly doubles the clearance margin; the overtake state is what makes the pass possible at all.

The four backends aren’t a spec sheet — they’re the payoff of keeping the controller behind the contract. The same MPC problem runs through a heavy nonlinear NLP, a lightweight convex backend, and a real-time C solver, and the convex backend in turn solves under any installed cvxpy solver. Every one solves every step cleanly with near-identical tracking; the choice is a config switch:

Two bar-chart panels. Left, MPC backends: casadi+ipopt at 1.69 ms and cvxpy at 4.41 ms mean per-step solve time, both solving 100% of steps; acados+HPIPM shown hatched as install-gated on macOS. Right, cvxpy solver sweep: OSQP 4.34 ms, SCS 4.41 ms, CLARABEL 4.79 ms, HIGHS 10.07 ms, all solving 100% of steps with about 0.028 m tracking error.

Real closed-loop runs of conlab’s NominalMPC on one tracking task. Left: the backend layer (benchmark_mpc.py) — same problem, different engine. Right: the cvxpy solver sweep (compare_mpc_solvers.py) — solver-agnostic solvability. A fourth dependency-free stub backend keeps CI runnable with no solver installed; acados is install-gated on macOS and runs in Docker/CI.

I then ran a deep architecture review (2026-07-02) before locking anything toward hardware. The verdict I care about: the four-shell separation held under scrutiny — Shell 1 has zero ROS imports, Shell 3 nodes are genuinely thin, and the tracklib boundary is consumed cleanly with nothing reimplemented. The debt is where I’d expect it, concentrated at the two boundaries hardware will stress: the ROS runtime layer (nodes not yet tested at runtime, topic/frame grammar half-migrated to convention) and a diverged parallel vehicle model. Naming that debt honestly, before VT5 bakes it into hardware bringup, is the point of reviewing early.

The decisions, and what they cost

An architecture is the set of things it refused to do. These are the four that shaped the rebuild — each recorded with what it gives up, because a decision without its cost isn’t a decision, it’s a sales pitch.

Trade-offs — what was chosen, and what it costs

How does a new experiment get expressed?

chose
One codebase, orthogonal config axes
over
a branch per experiment · a worktree · a forked drive script
costs
the cheap one-off is structurally unavailable — a new experiment needs an axis before it can run at all

This is the decision the whole rebuild exists to make. The legacy platform forked because forking was the fastest path for any single experiment; the cost only showed up at the tenth one, as ten diverging copies of a control loop. Making the fast path unavailable is the point, and it is a real tax: an experiment that genuinely doesn’t fit the axes has to widen the model before it can run.

Where does algorithm code meet ROS?

chose
A thin versioned contract package: conlab_interfaces + base classes
over
one shared msgs package across every stack · rclpy called directly from the algorithms
costs
a second place to edit whenever a message shape moves, plus a contract test suite that has to stay green

The pooling stance across my ROS 2 stacks is to share the shape — message definitions, base classes, naming conventions — and never a single monolithic msgs package that couples otherwise-independent stacks to one release cadence. The seam is what lets me hand the lab a runnable module rather than a repository to merge into.

Is motion capture a hardware dependency?

chose
Mocap as a ground-truth *seam*, with sim and OptiTrack backends
over
gating all pose work on physical rig access
costs
the sim backend is real code to maintain, and it can drift from what Motive actually reports

Treating mocap as a contract rather than a device is what kept VT0–VT4 moving without the rig. The estimator — not a pose topic — is the composition point, so a run that reads OptiTrack and a run that reads a simulated ground-truth publisher differ by configuration, not by code path.

Which solver does the nominal MPC target?

chose
Four backends behind one interface (cvxpy/OSQP, acados, …)
over
a single CasADi-first stack
costs
four implementations that must agree — a divergence between them is a silent correctness bug, not a crash

Convex-first, because the original lab controller was a convex QP and the research value is in the formulation, not in the autodiff machinery. Keeping several backends is a deliberate hedge against the embedded deployment target, and the reason the contract tests matter: agreement between backends is the invariant, and nothing else checks it.

What’s next — VT5, and the config-not-fork foundation

VT5 — the hardware bridge — is the only unlanded rung. A thin per-platform como/ deploy shell, aarch64 CI, real ECU, benchmarked against the lab’s prior multi-car reference stack. It’s deferred until the spine is solid precisely because hardware freezes contracts: the moment topic names, frames, and QoS go into launch files and lab muscle memory, they’re expensive to change.

Which is why the current design work is a distribution & experiment-topology spike (designed 2026-07-04; not yet built) — the piece that turns the config-composition principle from an aspiration into a mechanism. The proposal is a small data model — an AgentProfile and a RunManifest (Shell-1, ROS-free) — plus a compiler, manifest_to_launch, that is the one place the node graph is wired. The scattered per-agent parameters of today (visibility across three knobs, a roster declared three times, four ~250-line bespoke drive scripts) collapse into one manifest per experiment and one generic driver. The acceptance test is the one that names the whole architecture: the DR-CVaR mixed-information run — coordinator-informed ego, local-only opponent — expressed as a single config file, running the same node code for both agents, and runnable either co-located in sim or split across two DDS graphs by flipping one deployment block. Change an agent’s information access, or add a third car, and it’s a config edit — never a new script, branch, or worktree.

That’s the through-line from the legacy monolith to here: I’m not just porting a ROS 1 stack to ROS 2. I’m removing the structural reason the old one forked, so the lab can run an experiment I hand them — and the one after that — without cloning the codebase to do it.

The architecture — information topology × deployment topology

The centerpiece: the contract seam (vertical, per-agent) is fixed; information topology and deployment topology are two independent configuration axes composed over it. A DR-CVaR experiment is one point in that product — the two agents are structurally identical node chains, and the only difference between ego and opponent is their information block (the dotted edges).

flowchart TB
  subgraph MANIFEST["RunManifest — the experiment IS this config (never a fork)"]
    direction LR
    INFO["information topology<br/>(per-agent: sees / denies /<br/>reacts_to_peers / plan_source)"]
    DEPLOY["deployment topology<br/>(colocated sim ⇄ distributed hw;<br/>pose QoS, discovery)"]
    HET["heterogeneity<br/>(SE(2) car / SE(3) drone)"]
  end

  MANIFEST -->|"manifest_to_launch()<br/>the one place topology is wired"| GRAPH

  subgraph GRAPH["compiled node graph"]
    direction TB

    subgraph COORD["optional centralized layer"]
      C["BaseCoordinator<br/>coordinate(fleet) → per-agent plans<br/>/coordinator/…"]
    end

    subgraph EGO["agent: car0 — coordinator-INFORMED ego"]
      direction TB
      E1["localize (mocap → pose)"] --> E2["BaseStateEstimator<br/>(pose → velocity)"]
      E2 --> E3["project onto Track/Road<br/>waypoints_ahead  (tracklib)"]
      E3 --> E4["BasePlanner"]
      E4 --> E5["BaseController<br/>(NominalMPC · 4 backends)"]
      E5 --> E6["BaseSafetyFilter<br/>(DR-CVaR)"]
      E6 --> E7["command → drive → MCAP"]
    end

    subgraph OPP["agent: car1 — LOCAL-ONLY decentralized opponent"]
      direction TB
      O1["localize"] --> O3["project (tracklib)"]
      O3 --> O4["BasePlanner"] --> O5["BaseController"] --> O7["command → drive"]
    end
  end

  C -. "plan_source = coordinator" .-> E4
  EGO -. "sees: all (observes opponent)" .-> OPP
  OPP -. "sees: [] (blind to ego)" .-x EGO

  TRACK[("tracklib<br/>Track / Road / TrackGraph")] --- E3
  TRACK --- O3
  TELEM[("telemetry<br/>mocap adapters · MCAP · Foxglove")] --- E1
  TELEM --- O1
  IFACE[["conlab_interfaces — the contract seam<br/>(msg shapes + base classes; the stable boundary)"]]
  IFACE -.->|binds| EGO
  IFACE -.->|binds| OPP
  IFACE -.->|binds| COORD

  %% accent-orange = the config axes (the whole idea); grey = shared libraries.
  %% self-contained node fills so they read on both light and dark backgrounds.
  classDef axis fill:#ffe6d5,stroke:#ff5400,stroke-width:2px,color:#7a2e00;
  classDef lib fill:#edece7,stroke:#8a857c,color:#2a2824;
  class INFO,DEPLOY,HET axis;
  class TRACK,TELEM,IFACE lib;

Findings — what the pipeline audit turned up

A scenario slate that passes is not the same as a scenario slate that means something. Auditing the pipeline behind the passing runs produced four findings, and none of them were caught by a failing test — every suite was green throughout. They are recorded here in the state they’re actually in.

Findings — what broke, and what changed because of it

Every tracking number in the slate looked clean — max cross-track 0.036 m, lane margin 0.491 mpartial

cause
The bridge built the f1tenth_gym world without passing vehicle params, so the physics integrated the gym's default F1TENTH: +32% wheelbase (0.33 vs 0.25 m), +89% mass (3.74 vs 1.98 kg), +96% yaw inertia
fix
The plant now reads its parameters from the same configs/vehicle/*.yaml file the controller and the scorer read
ref
VT_PIPELINE_ANALYSIS · F1

The controller was modelled on a 0.25 m COMO, the scorer measured a 0.60 × 0.30 m COMO footprint, and the plant integrated a 0.33 m, 3.74 kg F1TENTH. Three sources of truth for one vehicle — one of them dead code, and the live path used none of them.

What makes this the finding I most want on the page: nothing failed. The closed loop absorbs a 32% steering-gain error without complaint, so every scenario still passed. The numbers were simply measurements of a car that does not exist, which no test could have told me. The slate is being re-measured against the corrected plant before any of it is quoted again.

Six-car runs crawled at 0.12× real time, so I shipped a knob to cut the plant's costopen

cause
97–99% of the plant's compute raycasts 1080 beams per agent per step into a laser scan the bridge never reads — but the plant is only ~10% of the end-to-end loop; ROS transport is the other ~90%
fix
The knob ships defaulted OFF and no scenario sets it; the 6.7× it can buy is contingent on a headless runner that takes ROS out of the loop first
ref
VT_PIPELINE_ANALYSIS · F2

Measured end-to-end, 1080 beams → 235.3 s and 108 beams → 232.9 s. No effect, inside the run-to-run spread. The speedup was real in isolation (2 agents: 9.5× → 137× with the scan off) and completely unreachable in place.

The correction is the useful part: the arithmetic needed to predict this was already written in my own analysis — plant ceiling 0.9×, full stack 0.09× — and I optimized the 10% anyway without reading it. Amdahl’s law is not a subtle result; I still had to pay for it in a shipped feature that buys nothing and costs wall-contact fidelity.

Two byte-identical six-car runs differed 48% in wall time — 235.3 s vs 158.6 sopen

cause
Unquantified run-to-run variance in the ROS/DDS scheduling of the multi-agent graph
fix
None yet — the variance has to be characterized before it can be designed around
ref
VT_PIPELINE_ANALYSIS · F2 addendum

The measurements themselves agreed closely across the two runs (lane margin 0.492 / 0.516 vs 0.492 / 0.513) — but the reported closest pair changed, car2/car5 in one run and car0/car3 in the other. A metric that identifies a different pair on identical input is a metric I cannot yet quote for a sweep. Measuring the spread is the prerequisite, not an optimization.

Running a SuperCOMO instead of a COMO — a physically larger car — changed nothing in the resultsopen

cause
Collision radii live outside configs/vehicle/, and the DR-CVaR filter carries a single body_half_extents shared by ego and obstacle, which under-pads a mixed-platform pair by 7.5 cm per side
fix
Registered as R1 in the heterogeneity scope; the per-agent vehicle object it needs does not exist yet
ref
HETEROGENEITY_SCOPE · R1

The config-composition claim held exactly where it was designed to: a second platform is a config file, with zero changes under algorithms/ and no per-platform branch. Both profiles overtake.

But the reason it was so easy is the finding. The footprint difference could not propagate, because twelve scripts hardcode load_vehicle_config("como") and there is no per-agent vehicle object for a heterogeneous run to vary. Heterogeneity that costs nothing to add is usually heterogeneity that isn’t reaching anything.

Updates

Reverse-chronological log below the evergreen case study.

  • 2026-07-04 — Distribution & experiment-topology spike designed: AgentProfile + RunManifest + a manifest_to_launch compiler, with the DR-CVaR mixed-information run worked as a single config file. The “config, not fork” foundation, on paper.
  • 2026-07-02 — Deep architecture review passed: four-shell separation holds; debt localized to the ROS runtime boundary and a duplicate vehicle model — named before VT5 freezes it.
  • 2026-07-01 — Capstones landed: visual multi-agent DDS demo + overtake-and-merge in the planner.
  • 2026-06-21 — conlab_interfaces keystone built (Jazzy colcon, 29/29); VT0–VT5 spine scoped.
  • 2026-06-18 — Platform reframe: from “personal thesis stack” to “lab-deliverable platform,” contract package named as the keystone seam.
Full spec
Stack
Python 3.11 &middot; ROS 2 Jazzy &middot; RoboStack/pixi &middot; rclpy &middot; CycloneDDS &middot; OptiTrack &middot; Foxglove / MCAP &middot; casadi &middot; cvxpy &middot; acados &middot; f1tenth_gym
Hardware
COMO &middot; SuperCOMO &middot; Crazyflie (heterogeneous, planned) &middot; ClearPath Jackal &middot; OptiTrack motion capture
Collaborators
Tyler Summers (PI, CONLab / UT Dallas)