Eros Marcello·Design Engineer: Frontier Science, Deep Tech & High-Consequence Systems
01The sixty-second read
If you read nothing else on this page.
0h
Concept to shipped
One working day, two people
0
Telemetry domains fused
Ground, air, orbit
0%
Real public feeds
Nothing mocked for the demo
0
Console surfaces designed
Panels, views, states
0
Track won
Defense + Military
What it is
An operator console that fuses NASA Deep Space Network ground-station telemetry, ADS-B aircraft transponders and the CelesTrak satellite catalog into one deconfliction picture, across dual apertures: surface and space.
Why it matters
Those three domains each have excellent telemetry and no shared picture. Today the deconfliction happens in a person’s head, on a phone call, across three screens. Dark Harvest makes the conflict a first-class object, self-spawns agents to work it and refuses to execute anything without recorded human authority.
What I did
The name, the brand, the product design, the information architecture, the design system and the entire frontend: every pixel of the interface layer, written in production React and TypeScript rather than mocked up. Ernest Yeung built the backend, the telemetry and the agent runtime beneath it.
Those counters ran once, when their tile first entered the viewport and won’t run again. On this page as in the product, motion reports an event, never a timer.
The board on the floor. Palo Alto, 25 JUL 2026, 16:53.
Sixteen fifty-three
Ninety-seven minutes before submission, on a borrowed table, running on live public telemetry.
What is on that screen is the same build deployed today: the aperture ring holding a surface violation, the ground segment carrying real Deep Space Network contention and the authority gate open at step one of two. No mock data was used at any point in the day, including the demo we presented.
Everything below this line was captured from that product rather than drawn to resemble it.
02Why nothing deconflicts
Ground stations, aircraft, and satellites each have excellent telemetry. None of them can see each other.
DSNDeep Space Network
14 dishes across Goldstone, Madrid, Canberra. Band, rate, pointing, claimants.
eyes.nasa.gov/dsn/data/dsn.xml
Knows nothing about the aircraft above the dish.
ADS-BAircraft transponders
Position, altitude, ground speed, squawk, for every cooperative aircraft in the volume.
adsb.lol → airplanes.live failover
Knows nothing about the antenna’s look angle or the pad below.
TLESatellite catalog
Two-line elements, SGP4-propagated to WGS84 position and station look angles.
CelesTrak GP
Knows nothing about the launch order or the range keep-out.
So the deconfliction happens in a person’s head, on a phone call, across three screens. It works because the people are good at it. It fails quietly, it doesn’t scale, and nobody can reconstruct afterwards what was known and when.
Dark Harvest makes the conflict a first-class object. One aperture, three domains, contention rendered the same way in all of them. Given how consequential that job is, the product stands on two pillars, and every design decision downstream is an elaboration of one of them.
01
Provenance
A comprehensive agent roster, spawn ledger and control stream surface every autonomous behaviour, every deduction and every proposed execution. An evidentiary chain of custody that’s legible at a glance and auditable after the fact. If an agent did something, there’s a record of what it did, what it was allowed to touch and what it concluded.
02
Human oversight
A supervisor authority manifest animates the moment a conflict is detected, giving the operator frictionless recourse: tactile review, authorize, reject. The control plane will refuse a dispatch it hasn’t been granted authority for and say so on the record. Autonomy proposes; a human commits.
03Domain immersion
I don’t learn a high-consequence domain by reading about it. I sit with the person who has operated it.
Frontier domains do not hand you a brief. They hand you an operator who has done the job for a decade and has never been asked to describe it. The work is getting the tacit model out of their head and into something you can design against, fast enough to matter and precisely enough that you are not inventing physics.
I run a domain-immersion protocol for exactly this. What it produces, over time, is not notes: it is a library of interaction primitives for high-consequence work, built once and carried between domains. That is the reason seven hours was enough. The color ramps, the type scale, the provenance grammar, the uncertainty treatments, the human-in-the-loop gate pattern: none of that was invented on the day. It was already built, already tested, already argued about.
Most design system work spends its first days on primitive setup. On a seven-hour clock that is fatal. Ours was done months earlier, so the day went where the time was actually scarce: the domain, and the seam between two people building opposite halves of one system.
Uncertainty
Confidence, spread and what isn’t known, rendered as a value and never as a blank.
Provenance
Where every number came from, carried on the number itself rather than in a footnote.
Workflow gates
Staged decisions with branching logic and an explicit human-in-the-loop commit.
Machine explanation
Why the system recommended what it did, in language the operator already trusts.
Mission-critical primitives
Calm by default, error-resilient, single source of truth, time-aware.
Multi-stakeholder views
Operator, supervisor, auditor: one state, three readings of it.
04The seven-hour clock
Two people, two halves, four sync points. Everything in between was built without checking in, which only works if the contract was agreed before either half existed.
Ernest and I worked autonomously and synced on a handful of deliberate beats. That means the specification had to be pre-cognitive on both sides: I had to tell him what the ontological interface layer would surface, what the operator would be shown and how the thing would be productized, all before he had written the endpoint that would feed it. He had to tell me the null semantics and the cadence before I had drawn the panel that would render them. The seam held because we agreed on shapes, not on screens.
Drawn with the product’s own spawn-lane idiom: the build as a two-agent spawn tree
EROS
IA + board architecture
What an operator must see at once, what they may drill into and what must never be more than one action away.
Aperture ring + ground segment
One component, three aperture kinds. Landing zone, airspace volume, antenna. Contention renders as overlapping arcs in all three.
Agent side + authority gate
Roster, spawn budgets, spawn lanes, ledger, control stream. Then the two-step gate the whole system funnels into.
Replay parity
Every adapter failover announced in the stream. No spinner, no blanked panel, no fabricated track.
Collapse and loss-of-lock state machines, scopes, budgets and the Band room the agents speak in.
Ontology + custody ledger
Typed object graph with per-property provenance, over a hash-chained evidentiary ledger.
09:30
Domain lock
11:30
Contract handshake
13:50
Seam check
16:30
Submitted
09:30 DOORS12:0014:0016:30 SUBMIT
05The interface layer
One board. Everything an operator needs to decide whether to stop a launch, and nothing they don’t.
Tap a marker to read the rule that panel enforces
The board is a fixed hierarchy, not a dashboard of widgets. The aperture ring is the subject. The ground segment is the constraint. The timeline is the window. The banner is the decision. The right rail is the machine explaining itself. An operator reads it in that order every single time, because the layout never rearranges itself in response to the data.
That is a deliberate refusal. Adaptive layouts feel intelligent and are hostile in a time-pressured environment: the muscle memory that lets someone find the violation in 200 milliseconds is built on the panel being in the same place it was yesterday. The console changes what it says, never where it says it.
The authority gate, in three real states
01 · IDLE: human authority required, step 1 of 202 · ARMED: step 2 of 2, approver named, Enter inert03 · AUTHORIZED: hold applied, lanes halted, recorded
One component, three aperture kinds
AIRSPACE VOLUME: bearing / range against the launch keep-outANTENNA: azimuth / elevation for a contended dishDECISION RECORD: the drawer behind the banner
06The ontology
Underneath the board is a typed object graph, and every single property on it knows where it came from.
01 · OBJECTS
Typed, counted, filterable
02 · GRAPH
Deterministic radial layout, nothing jiggles on a timer
03 · PROFILE
Every property carries its own provenance
A dish is an object. A spacecraft is an object. The claim one makes on the other is a typed link with its own provenance and its own validity window. When a source stops asserting a link, the link closes rather than vanishing, so a question about what was true at 22:42Z still has an answer at midnight.
The graph canvas is a deterministic radial layout, not a force simulation. A force sim animates on a timer, and this system does not permit that: node positions here are a pure function of the data, so the picture moves when the graph changes and at no other time. It also means the same graph draws the same picture every time, which is what makes a screenshot of it admissible as evidence.
The profile pane is where the provenance grammar earns its keep. claimant_count 2 is marked DER and states what it was derived from. azimuth_deg 12 is marked OBS and carries its source URL. Nothing on that pane asks the operator to trust it: every value volunteers its own lineage.
ROOTED ON A GROUND STATION · DEPTH 2 · STATION → DISHES → SPACECRAFTDSS34 · CONTENDED TRUE, DERIVED FROM CLAIMANT_COUNT, DERIVED FROM TARGETS
07An agent-centered design system
Most design system case studies end in Figma. The components are polished, the variants are neat, and none of it has ever had to survive a product. Everything in this section is live on this page, drawn by the product's own code.
Tokens, and the two that had to move
The system this console inherits ships neither cyan nor green: it is a dark-first hot-pink and violet two-tone. Two of its values did not survive contact with an instrument-scale interface, and moving them was the first real design decision in the project.
Measured against
Token
Hex
Role
Contrast
AA
C.obs
#060309
Ground
N/A
SURFACE
C.pan
#130A16
Panel substrate
N/A
SURFACE
C.pan3
#1C0F22
Panel, elevated
N/A
SURFACE
C.fg
#F7EEF6
Primary text
16.23:1
PASS
C.dim
#C8A6C4
Labels, metadata
8.51:1
PASS
C.faint
#92758E
Axis text, unknown values· lifted for AA
4.52:1
PASS
C.bdr
#2A1830
Hairline
N/A
SURFACE
C.live
#F82090
Informational · active · live · selected
4.91:1
PASS
C.nom
#B96CE6
Nominal · clear · approved
5.57:1
PASS
C.caut
#FFB84D
Caution · contention · awaiting human
10.71:1
PASS
C.viol
#FF3366
Violation · hold · control-plane block
5.19:1
PASS
C.deg
#8B71BA
Degraded, paired with desaturation· lifted for AA
4.53:1
PASS
Ratios computed at render time from the same module the console imports. See src/lib/case/contrast.ts. Normal-text AA is the only bar that applies: the console labels at .60rem, so nothing in it qualifies for the large-text 3:1 exemption.
C.faint · LIFTED AT HUE 308°
AXIS TEXT · UNKNOWN
UPSTREAM #8A6D86 4.04:1 FAIL
AXIS TEXT · UNKNOWN
SHIPPED #92758E 4.52:1 PASS
Failed AA against the panel it’s used on. The console labels at .60rem, about 9.6px, so nothing in it qualifies for the large-text 3:1 exemption, and the upstream value had nowhere to hide. Same hue, same saturation, lightness raised until it cleared. The design reads unchanged. Both ratios above are computed from the hex at render time, not typed in.
C.deg · LIFTED AT HUE 261°
AXIS TEXT · UNKNOWN
UPSTREAM #7A5CB0 3.49:1 FAIL
AXIS TEXT · UNKNOWN
SHIPPED #8B71BA 4.53:1 PASS
Failed everywhere it was used, by a wider margin. Degraded state is still paired with desaturation, so the treatment is untouched. Only the text now clears the bar.
The escalation ladder
Four states an operator reads monotonically, left to right, without a legend. Violet is deliberately the quiet end: nominal should not compete for attention, and the loudest colour in the palette belongs to the one state that stops a launch.
NOMINALQuiet. Nothing is asking for you.
LIVEInformational. Active, selected, receiving.
CAUTIONContention. Awaiting a human.
VIOLATIONHold. The control plane is blocked.
Provenance, encoded in fill
The upstream contract specified two markers. A third was needed: the launch claimant and the keep-out geometry are neither observed off a feed nor derived from one: they come off the launch order. Rendering them as either would have been a lie, so the vocabulary grew.
OBSObservedCame off a feed, live or recorded. Solid fill, round dot.
DERDerivedComputed, estimated, or model-produced. Hatched fill.
SCNScenarioLaunch-order constant, operator-supplied. Open square, square corners.
Switch the page to VISION MONO or DEUTAN in the corner. All three markers stay distinguishable, because the fill and the corner radius carry the meaning and the colour is only reinforcing it. That is the test; this is the page shipping it rather than claiming it.
The motion contract
There is no spinner anywhere in this product. A spinner is banned because it depicts nothing: it turns whether or not anything is happening. A lane that grows because an agent is genuinely still alive depicts something. The test is not whether pixels move; it is whether the movement is reporting a fact.
Demo
Motion
Bound to
Agent dot pulses once
One observed emission. It stops if the adapter stalls.
Live spawn lane grows
The agent hasn’t returned. The width is its lifetime.
Unresolved right edge
endRelS === null. The end time isn’t yet known.
Lane draws in from parent
A child agent spawned.
Stream row slides in
A new event reached the head of the stream.
Breach marker slams and freezes
A budget axis breached. It never drifts back down.
Chain head advances
A custody record was committed to the ledger.
Each of these plays on your click: a real operator input, which is the only reason they are allowed to move here at all. Flip MOTION OFF in the corner and every one collapses to its end state. Nothing in the console is knowable only through movement, so suppressing motion loses no information.
Tactility, weighted by consequence
Press travel is not uniform. It scales with what the control does, so an operator's hand learns the difference between sorting a table and authorizing a range hold. The heavy weight adds an inset shadow so the control visibly compresses rather than merely moving, and release overshoots by half a pixel before settling. That overshoot is the entire reason it reads as a physical button rather than a sprite swap. Press these.
Toggles, sorts, navigation
Panel actions, drawer
The human-authority gate
The layer a component library doesn’t have
For an agentic product, tokens and components are the easy half. The system also has to carry when an agent may act, what it may touch, what it must surface, and where a human must be in the loop, and each of those has to be a visible surface rather than a policy file. Every row below is a real panel in the shipped console.
Surface
What it carries
The rule it enforces
Agent roster
Granted and denied tool scopes, per agent, visible without opening a config.
An agent may only touch what its scope chips say it may touch.
Spawn budgets
Depth, fanout and live-agent ceilings with a frozen breach marker.
Autonomy is bounded by a number an operator can read, not by a prompt.
Spawn lanes + ledger
Parentage, lifetime and whether the work reached the resolution or orphaned.
Every spawn is attributable to the agent that caused it.
Control stream
Refusals, escalations and the policy that produced them, quoted.
A blocked action is louder than a permitted one.
Authority gate
Two deliberate steps, a named approver and a recorded timestamp.
Autonomy proposes. A human commits. The commit is the training signal.
Custody ledger
Hash-chained records of every committed decision.
The record is answerable later, not just visible now.
Stated as a loop: human intent → the system and its agent rules → generation → human validation → production → governance and feedback. In this product that loop is not a diagram. The operator’s AUTHORIZE or REJECT posts to the monitor as labelled feedback, and that label is what drives the bounded policy evolution underneath. The approval gate is the training signal. Speed without constraints produces drift; the constraint here is a person, and the system is built so that being the constraint takes two seconds rather than two minutes.
The constitution
Seven invariants. These are not stylistic preferences. Breaking one produces a console that lies to an operator.
Nothing is fabricated.01
An unknown value renders UNKNOWN, or the em-dash sentinel where the contract names it. Never a zero, never a placeholder, never a stale value silently swapped in.
Every claim carries provenance.02
OBS came off a feed. DER was computed or model-produced. SCN came off the launch order. Fill encodes it as solid, hatched or open, so it survives colour-blindness and a bad display.
Stale and loading never share a treatment.03
There’s no spinner anywhere. A failing feed says so, holds its last known values and runs its age counter upward.
Degradation is announced.04
Every adapter failover is written to the stream. A panel never silently blanks.
The gate is two deliberate steps.05
Enter is inert on AUTHORIZE HOLD: it reports that it does nothing rather than firing. Space or click only.
Every animation is bound to a real state transition.06
Nothing animates on a timer alone. If the console can’t name the event that caused a movement, that movement doesn’t ship.
Synthetic is unmistakable.07
Anything synthetic carries an explicit SYNTHETIC / NOT LIVE marker. Demo replay never impersonates a feed.
08Interaction patterns for agentic systems
Six problems every agentic product has to solve. They are the same six each time, which is why the vocabulary is worth more than any one implementation of it.
01
Streaming and progressive rendering
A response that arrives over time has to stay legible while it’s still incomplete.
What this one ships
The event endpoint serves JSON by default and Server-Sent Events additively, negotiated on the Accept header, so adding a streaming client never forks the contract the other consumers depend on. There’s no spinner anywhere in the product: a surface with work in flight shows what it already has, plus a running age and never a placeholder standing in for a value.
02
Citations and provenance
A claim an operator is going to act on has to carry where it came from, at the point of use.
What this one ships
Three fill-encoded markers ride every value: observed, derived, scenario. Derived values name what they were derived from. Model-produced prose is marked as such inline rather than in a footnote. Underneath, an append-only evidence log records each assertion with its source and content id, so a decision stays answerable after the session that made it.
03
Human review and approval
The distance between what a model proposes and what a system executes is the entire safety argument.
What this one ships
A two-step gate with a named approver and a recorded timestamp. Enter is deliberately inert on the commit control and reports that it did nothing. Upstream of the gate, the control plane refuses a dispatch it has no authority for and writes the refusal, with the policy quoted, into the same stream the operator is already reading.
04
Trace inspection
You can’t debug an agent you can’t watch, and post-hoc logs are the wrong altitude.
What this one ships
A roster showing each agent’s granted and denied tool scopes without opening a config. A ledger showing what spawned what, how long it lived and whether the work reached the resolution or orphaned. Every row in the event stream expands to the raw payload behind it, and the recommendation opens into a full decision record.
05
Evaluation and the feedback loop
A system that adapts needs a labelled signal, and the only trustworthy label is a human decision.
What this one ships
The gate’s verdict is the label. Authorize confirms the detection; reject marks it a false positive. That posts straight back to the monitor and drives a bounded policy evolution: the confirmation window can widen, capped, and only if the candidate still catches the persistent case while filtering every labelled transient. The approval surface and the training surface are the same surface.
06
Bounded autonomy
Capability is not authority, and an operator needs to see the boundary rather than trust it.
What this one ships
Depth, fanout and live-agent ceilings rendered as gauges an operator reads at a glance. A breach marker that slams and freezes rather than drifting back down, because a breach that quietly heals is a breach nobody saw. Scope chips that show denied tools struck through beside granted ones.
The engineering underneath
An interface claim that can’t survive someone opening the inspector isn’t worth making. This is what the two surfaces are actually built out of.
Zero runtime dependencies
next, react, react-dom. No component library, no charting library, no animation library. Every primitive on both the console and this page is written here.
Hand-rolled visualization
The aperture ring is polar and arc geometry in raw SVG: bearing and range against clearance radii, azimuth and elevation for a dish. No D3, no canvas abstraction.
Deterministic layout
The object graph uses a radial layout rather than a force simulation, so node positions are a pure function of the data. The same graph draws the same picture every time, which is what makes a screenshot of it admissible.
One listener, not N
Cursor proximity across every panel is a single delegated pointermove listener on the shell, coalesced to animation frames and skipped entirely for coarse pointers and reduced motion.
Observers over timers
IntersectionObserver drives reveals and defers the live embed until it’s scrolled to. ResizeObserver drives the scaled frame. Nothing polls the layout.
Contract-tested wire
85 Python tests and 9 Rust tests, including a wire-contract suite that pins the exact JSON shapes the frontend renders, so a backend change that would break a panel fails in CI instead of in front of an operator.
A dependency-free safety core
Link classification, alert state, WGS84 geodetic conversion and topocentric look angles live in a Rust crate with no dependencies, so the safety-relevant path can move to an edge host without carrying a cloud graph with it.
No network font dependency
All three faces are vendored and served from the same origin. An operator console that blocks on a CDN isn’t an operator console.
09Interactive prototype
A scripted incident on a real clock. Telemetry closes, an agent self-spawns, the control plane refuses to act, and then it is your call. Press RUN.
DARK HARVESTSIMULATED · NOT LIVENOMINALT+00.0sRECOV-01 2600 m · BRG 213 · 3.6 m/s
SCENARIO C-4417 · LZ-1 VANDENBERG SFB
Aperture ringLANDING_ZONE · TRACKING
ASSETRANGE / BRG
RECOV-01OBS2600 m / 213
B1099SCN640 m / 356
PAD-CREW-AOBS2180 m / 074
RANGE-SAFE-2OBS2960 m / 148
Agent roster4 RUNNING
RANGEWATCHRUNNING
surface.assetsrange.clearancedsn.*
SKYWATCHRUNNING
adsb.pointadsb.failoverdsn.*
APERTURERUNNING
dsn.fetchadsb.*
ARBITERRUNNING
band.publishcontrol.dispatchall feed tools
Spawn budgetsWITHIN CEILING
DEPTH
1/5
FANOUT
8/10
LIVE
4/12
Custody ledgerNO RECORDS
A RECORD IS APPENDED WHEN A HUMAN COMMITS. NOT BEFORE.
Band + control streamINTERLEAVED · NEWEST FIRST
NO EVENTS YET · PRESS RUN
NOMINALLZ-1 + VBG-KEEPOUT-01 + DSS34
All four surface assets outside the advisory radius. Agents observing. Nothing is asking for you.
GATE CLOSED · NOTHING TO DECIDE
The moment that matters is at T+22. An agent that has correctly diagnosed the problem, computed a correct fix and has the tool to apply it, is refused, on the record, with the policy quoted. Capability was never the constraint. Authority was.
Try pressing Enter on AUTHORIZE HOLD. It does nothing, and it tells you it did nothing. Every other control in the product takes Enter. This one takes Space or a click, because reflexive Enter is how a tired operator authorizes something they did not read.
The custody record chains. Each entry hashes the one before it, so the ledger is answerable later rather than merely visible now. Here that is FNV-1a for display; the shipped chain is SHA-256 over canonicalised records in Postgres.
10Not a screenshot
The deployed console, running here, on the same public feeds. Everything above this line was captured from exactly this.
LIVE CONSOLE · MOUNTS ON SCROLL
NOT A SCREENSHOTRendered at 1600px and scaled to 50%. The console is deliberately not responsive, and squeezing it would misrepresent its densityOpen full size ↗
11Designing in code
The whole build was AI-assisted, and saying so is the point rather than the caveat. What matters is which decisions stayed mine.
Tool
Where it sat in the loop
DeepSeek R1
Planning and architecture reasoning. Where the board structure and the failure modes got argued out before anything was drawn.
Qwen 4.6
Code autocomplete in the editor. Line-level, not decision-level.
Claude Code
Frontend implementation and iteration against a spec I held. Scaffolds, view-model builders, normalizers.
Claude Design
The console prototype that the shipped frontend was reconciled against.
Figma
Wireframes and board layout before any of it was code.
Band.ai
Agent-to-agent transport and the operator room. Ernest’s half.
The boundary I hold is not about typing. It is that the things which decide whether an operator can trust the screen (data modelling, information architecture, failure modes, accessibility, colour for data, what a value means when it is missing) never get delegated. Scaffolding, CRUD, API clients and boilerplate always do. Speed without constraints produces drift; the constraint is knowing which half is which.
Hand-written
Mine, line by line.
The token reconciliation, and the two contrast lifts that came out of it
The aperture ring: polar math, arc geometry, the three aperture kinds
The provenance marker system, including the third marker the contract lacked
The motion contract: every animation bound to a named state transition
The tactile press scale, weighted by consequence
Information architecture, view routing and the nav rail’s state model
Every panel’s information design: what is shown, at what size, in what order
The two-step authority gate, including making Enter deliberately inert
Model-assisted
Generated against a spec I wrote, then reviewed.
Component scaffolds against a spec I wrote
The derive/ view-model builders, one per panel
Corpus normalizers and the adapter failover chain
TypeScript types and the API client surface
Test scaffolding
Wireframed in Figma
Drawn before any of it was code.
Console board layout: the two-column grid and its density tiers
This page is a route inside the product’s own repository. It imports @/lib/tokens, the same module the console imports, so every swatch, every provenance chip, every press weight and every contrast ratio above is rendered by the system it is describing, not redrawn to look like it. Change a hex in that file and this page changes with the product. The screenshots come from a committed capture script that drives the real UI. There is no version of this case study that can drift from what shipped.
12What ships next
The console is one instantiation of a reusable mission-grade ontology suite. The design system is the governance layer that makes the next one cheap.
The productization thesis is simple. Nothing in the aperture ring, the provenance grammar, the spawn ledger or the authority gate is specific to launch ranges. Swap the ontology and the same board runs a UAS corridor, a port approach, a spectrum allocation or an autonomy-safety review. The expensive part was never the domain. It was building an interface layer that an operator will trust with a decision they can be deposed about. That part transfers.
Evaluation and trace surfaces
The spawn ledger already answers what an agent did. The next surface answers whether it was right: run-over-run comparison, regression on replayed incidents and a diff between two policy versions on the same corpus.
Human-on-the-loop, not just in it
The gate stops one action. Supervising a fleet means setting the standing conditions under which many actions are pre-authorised, and being told when the boundary is approached rather than crossed.
Multi-operator handoff
Shift change is when high-consequence systems lose state. Pending, critical, context, as a first-class surface rather than a verbal briefing.
Classification-aware rendering
The banner already declares a marking. The next step is components that know their own marking and refuse to render above it.
Systematised data tables
Sortable, virtualised and provenance-aware by default, so a dense record view is a component rather than a composition.
Replay-parity harness
Live and replay already share a normalizer and a cadence. Making that a test rather than a discipline is a day of work and permanent.
The safety core to the edge
Classification and geometry already have no dependencies. That crate can become an edge binary or an FFI oracle without moving Python with it.
The organisers, and the track sponsor Initium Technologies. Venture Dock, Nexla, Band, MiniMax, Mem0, RocketRide, Retriever AI, ElevenLabs, Render, Respan, Cerebras, Tencent EdgeOne, TokenRouter. The judges, and a genuinely strong field of competitors. Special thanks to Conrad Scheibye and Aaryan Khanna.
DEFENSE + MILITARY TRACK · PALO ALTO, CA · 25 JUL 2026
