Codio retweeted
A verification lead turned a $380,000 simulation bill into $34 a run by making the chip prove where it doesn't need testing
Verification eats most of a chip project's budget, and almost all of that compute goes into re-testing logic that nobody touched this cycle.
He made the design carry its own coverage map, so every run only exercises what actually changed and what that change can reach:
> Trace: each block records which inputs and states it can be influenced by
> Diff: a revision is compared against the last verified state, block by block
> Scope: the test set is cut to the reachable blast radius of the change
• What full regression was actually paying for
> Weeks of compute re-verifying blocks that hadn't moved in four revisions
> Test cycles spent on paths the change could never physically reach
> A green result that said nothing about whether the new logic was safe
• Why the saving is bigger than the number looks
> Engineers run the suite per change now, not once a week
> A bug is found hours after it's written, not in the next full pass
> Verification stopped being the thing the whole schedule waited on
A scoped regression now runs in about 25 minutes instead of nine days.
And the part that broke my brain:
A full pass used to cost more than a car and took nine days to come back.
The scoped one costs $34, finishes over lunch, and catches more real bugs.
Same silicon. One version pays for certainty about things nobody changed.
The cost was never verification.
It was verifying everything to avoid thinking about what changed ↓
A verification lead turned a $380,000 simulation bill into $34 a run by making the chip prove where it doesn't need testing
Verification eats most of a chip project's budget, and almost all of that compute goes into re-testing logic that nobody touched this cycle.
He made the design carry its own coverage map, so every run only exercises what actually changed and what that change can reach:
> Trace: each block records which inputs and states it can be influenced by
> Diff: a revision is compared against the last verified state, block by block
> Scope: the test set is cut to the reachable blast radius of the change
• What full regression was actually paying for
> Weeks of compute re-verifying blocks that hadn't moved in four revisions
> Test cycles spent on paths the change could never physically reach
> A green result that said nothing about whether the new logic was safe
• Why the saving is bigger than the number looks
> Engineers run the suite per change now, not once a week
> A bug is found hours after it's written, not in the next full pass
> Verification stopped being the thing the whole schedule waited on
A scoped regression now runs in about 25 minutes instead of nine days.
And the part that broke my brain:
A full pass used to cost more than a car and took nine days to come back.
The scoped one costs $34, finishes over lunch, and catches more real bugs.
Same silicon. One version pays for certainty about things nobody changed.
The cost was never verification.
It was verifying everything to avoid thinking about what changed ↓
Anthropic put a model inside the microscope loop and it stopped taking pictures, it started asking questions
Every imaging session is planned in advance, a fixed grid of positions captured whether or not anything interesting is in them, and the analysis happens weeks later.
Here the model reads each frame as it arrives and decides where the stage goes next, so the session narrows on whatever the sample is actually doing:
> Capture: one frame comes in, at low dose, on a coarse grid
> Read: the model scores it for anything that breaks the expected pattern
> Redirect: the stage moves toward the anomaly instead of finishing the grid
> Commit: only the interesting regions get the high-dose, high-resolution pass
• What steering the session surfaces
> Rare events that a fixed grid lands on by luck, if ever
> Compound interactions that only show up in a handful of positions
> Regions the standard protocol would have imaged last, after they'd changed
• Why this had to happen live
> A transient structure is gone by the time the session ends
> Dose spent on empty frames is dose you can't spend on the real one
> Deciding afterwards means deciding about data you already destroyed
One session now covers a tenth of the area and returns more usable events.
And the part that broke my brain:
The old protocol imaged 4,000 positions and found the interesting one at number 3,100.
The steered session found the same class of event in the first 40 frames.
Same sample. One version photographs everything and looks later.
The bottleneck was never the microscope.
It was deciding where to point it before you knew anything ↓
Codio retweeted
A Chinese chipmaker cancelled $4M a year in engineering hires and spent it on Opus 5.5 instead, and shipped ten times the designs
Most of the cost in chip design was never compute, it was the months of senior time spent turning a spec into something manufacturable.
They moved that work to the model and kept the people on judgement, so the floor now runs more projects than it has engineers:
> Spec: requirements go in once, as text, for every project on the floor
> Generate: layouts, verification setups and test benches come out of the same spec
> Review: engineers only read what the model flagged as uncertain
> Ship: the rest moves to tapeout on the house rules it was generated against
• What the token math actually looks like
> Opus 5.5: $4 per million in, $20 out, cache reads at $0.20
> Batch rates halve that again, $2 in and $10 out, for anything that can wait
> A full design pass lands near $30 in tokens against weeks of engineer time
• Where the 10x actually came from
> The same headcount now carries ten projects instead of one
> Verification stopped being the queue everything waited behind
> Revenue scaled with projects shipped, not with people hired
One full design pass regenerates in about 40 minutes.
And the part that broke my brain:
Their old limit was how many senior engineers they could hire in a year.
The new limit is how many customers they can sign, and the token bill barely moved.
Same floor. One version was capped by a hiring market.
The constraint was never the silicon.
It was how many people had to touch it ↓
A Chinese chipmaker cancelled $4M a year in engineering hires and spent it on Opus 5.5 instead, and shipped ten times the designs
Most of the cost in chip design was never compute, it was the months of senior time spent turning a spec into something manufacturable.
They moved that work to the model and kept the people on judgement, so the floor now runs more projects than it has engineers:
> Spec: requirements go in once, as text, for every project on the floor
> Generate: layouts, verification setups and test benches come out of the same spec
> Review: engineers only read what the model flagged as uncertain
> Ship: the rest moves to tapeout on the house rules it was generated against
• What the token math actually looks like
> Opus 5.5: $4 per million in, $20 out, cache reads at $0.20
> Batch rates halve that again, $2 in and $10 out, for anything that can wait
> A full design pass lands near $30 in tokens against weeks of engineer time
• Where the 10x actually came from
> The same headcount now carries ten projects instead of one
> Verification stopped being the queue everything waited behind
> Revenue scaled with projects shipped, not with people hired
One full design pass regenerates in about 40 minutes.
And the part that broke my brain:
Their old limit was how many senior engineers they could hire in a year.
The new limit is how many customers they can sign, and the token bill barely moved.
Same floor. One version was capped by a hiring market.
The constraint was never the silicon.
It was how many people had to touch it ↓
A cell model that runs the same cell twice and reports where the two copies stopped agreeing
Every simulation treats a cell as deterministic, same inputs, same outcome, which is the one property real cells have never had.
Here the same cell is run thousands of times from identical starting conditions, and the output is the spread, not the average:
> Replicate: one cell, one state, ten thousand independent runs
> Diverge: the point where outcomes split is located, not smoothed over
• What the spread shows that an average hides
> Two cells in identical conditions choosing different fates within minutes
> A pathway that looks reliable at the mean and fails in 12% of runs
> The exact molecule count where the outcome stops being predictable
• Why averaging was always the mistake
> A cell doesn't experience the average, it experiences one run
> The rare outcome is the one that becomes a tumour or a resistance case
> Biology's interesting behaviour lives in the tail, not the middle
Ten thousand replicate runs finish in about 20 minutes.
And the part that broke my brain:
The averaged model said this pathway always resolves the same way.
Run individually, one in eight cells went somewhere else entirely.
Same cell. One version describes a cell that doesn't exist.
The answer was never the mean.
It was how far apart identical cells end up ↓
Codio retweeted
A Chinese plant let Anthropic read its own machines and found 8% of its yield had been dying in a PDF
Most design teams work against a process spec, a frozen document describing what the fab can do.
Here the model reads the line itself, so a design is shaped by the equipment that will build it, on the day it will be built:
> Sense: yield data, tool drift and chamber conditions stream in from the floor
> Shape: the layout is generated against what the line can hold right now
> Flag: any feature the current equipment can't hit reliably gets redesigned
> Return: the finished design goes back with the tolerances it was built for
• What designing against the real line kills
> Features that were legal on paper and quietly cost yield every single run
> Rework caused by a tool that drifted months ago and nobody told design
> The conservative margin everyone adds because the spec can't be trusted
• What this cost them
> No new equipment, no new headcount, the data was already being logged
> The yield gain paid for the whole integration inside one production month
> Designers stopped guessing, which was never a line item anyone tracked
A design re-shapes against current line conditions in about 25 minutes.
And the part that broke my brain:
Design and manufacturing sat in the same building and spoke through a document.
The model read what the machines were actually doing and yield moved in a week.
Same plant. One version designs for a factory that existed two years ago.
The gap was never between the design and the process.
It was between the process and the paper describing it ↓
A Chinese plant let Anthropic read its own machines and found 8% of its yield had been dying in a PDF
Most design teams work against a process spec, a frozen document describing what the fab can do.
Here the model reads the line itself, so a design is shaped by the equipment that will build it, on the day it will be built:
> Sense: yield data, tool drift and chamber conditions stream in from the floor
> Shape: the layout is generated against what the line can hold right now
> Flag: any feature the current equipment can't hit reliably gets redesigned
> Return: the finished design goes back with the tolerances it was built for
• What designing against the real line kills
> Features that were legal on paper and quietly cost yield every single run
> Rework caused by a tool that drifted months ago and nobody told design
> The conservative margin everyone adds because the spec can't be trusted
• What this cost them
> No new equipment, no new headcount, the data was already being logged
> The yield gain paid for the whole integration inside one production month
> Designers stopped guessing, which was never a line item anyone tracked
A design re-shapes against current line conditions in about 25 minutes.
And the part that broke my brain:
Design and manufacturing sat in the same building and spoke through a document.
The model read what the machines were actually doing and yield moved in a week.
Same plant. One version designs for a factory that existed two years ago.
The gap was never between the design and the process.
It was between the process and the paper describing it ↓
Engineer at a big tech company built a tool that finds viruses by ignoring every known virus, and a biotech firm bought it outright
Every discovery pipeline searches by similarity, which means it can only find things that resemble what's already in the database.
His tool never compares sequences, it looks for the structural signature of something being read and copied, whatever its letters happen to be:
> Fold: raw reads are modelled by the shape they'd produce, not the text they contain
> Match: shapes that behave like replication or translation machinery get flagged
> Rank: the ones with no sequence relative anywhere go to the top, not the bottom
• Why similarity search was always a ceiling
> A genuinely new family shares no sequence with anything catalogued
> The more novel something is, the lower it scores on every existing tool
> Decades of archives were searched with a method that filters out the new
• What the first pass turned up
> Ribosome-like structures in samples labelled as containing nothing
> Several candidate families with no relatives in any public database
> A pile of hits in data that had been sequenced, searched and shelved in 2014
One archive gets re-searched by structure in about six hours.
And the part that broke my brain:
The samples weren't new. They'd been sequenced, searched and found empty years ago.
The search was the thing that couldn't see them.
Same data. One method only finds what it already has a name for.
The limit was never the sequencing.
It was asking what does this look like instead of what does this do ↓
Codio retweeted
A Chinese fab wired Anthropic into its chip pipeline and cut design costs to almost nothing
Most of a chip isn't the clever part, and teams still pay senior engineers to redraw all of it every generation.
They split the die by who should own it, the commodity half generated and verified automatically, the differentiated half left entirely to humans:
> Classify: every block is tagged as commodity, adapted or genuinely novel
> Generate: commodity blocks are produced from the house rules, not redrawn
> Verify: those blocks are checked automatically against the same rules
> Reserve: the novel blocks never enter the pipeline, engineers own them outright
• What counts as commodity and nobody admits it
> Power distribution, clock trees, scan chains, reset logic
> Standard interfaces that have been the same for fifteen years
> Test structures that get copied from the last project anyway
• Where the savings actually come from
> Roughly 70% of the die stopped consuming engineer hours
> The same senior people now spend all their time on the 30% that matters
> A new generation reuses the rules, so the cost drops again each time
The commodity half of a die regenerates in about two hours.
And the part that broke my brain:
Their best engineers had been spending most of each project redrawing clock trees.
The pipeline took that work away and the headcount stayed the same.
Same silicon. One version pays senior salaries for solved problems.
The expense was never the hard part of the chip.
It was everything around it that nobody wanted to own ↓
A Chinese fab wired Anthropic into its chip pipeline and cut design costs to almost nothing
Most of a chip isn't the clever part, and teams still pay senior engineers to redraw all of it every generation.
They split the die by who should own it, the commodity half generated and verified automatically, the differentiated half left entirely to humans:
> Classify: every block is tagged as commodity, adapted or genuinely novel
> Generate: commodity blocks are produced from the house rules, not redrawn
> Verify: those blocks are checked automatically against the same rules
> Reserve: the novel blocks never enter the pipeline, engineers own them outright
• What counts as commodity and nobody admits it
> Power distribution, clock trees, scan chains, reset logic
> Standard interfaces that have been the same for fifteen years
> Test structures that get copied from the last project anyway
• Where the savings actually come from
> Roughly 70% of the die stopped consuming engineer hours
> The same senior people now spend all their time on the 30% that matters
> A new generation reuses the rules, so the cost drops again each time
The commodity half of a die regenerates in about two hours.
And the part that broke my brain:
Their best engineers had been spending most of each project redrawing clock trees.
The pipeline took that work away and the headcount stayed the same.
Same silicon. One version pays senior salaries for solved problems.
The expense was never the hard part of the chip.
It was everything around it that nobody wanted to own ↓
Anthropic's biology team built a microscope that reconstructs what the sample looked like before it was ever observed
Every image of living tissue is taken with light that damages it, so the first frame already shows a sample the instrument has started destroying.
The scope models its own damage as it goes, and reports the structure as it was at zero exposure rather than at the moment of capture:
> Dose: every photon delivered to every voxel is tracked, not estimated
> Decay: the structural change that dose causes is modelled forward in time
> Invert: the measured image is run backwards through that model to zero exposure
• What the correction exposes
> Fine structures that were always recorded half-collapsed, never intact
> Features that looked stable because the damage was uniform across the frame
> A whole class of artifacts the field had catalogued as real morphology
• Why this gets worse the more you zoom
> Higher resolution means more dose on less tissue, so detail costs damage
> The finest structures are the ones that die first, before you can see them
> Every microscopy paper on small features is reporting partially destroyed ones
One field of view reconstructs to zero exposure in about 40 seconds.
And the part that broke my brain:
A structure measured at 60nm across three decades of papers reconstructs to 94nm.
Nobody was wrong. Everyone was measuring it after the light had already hit it.
Same tissue. One version shows you what observing it did.
The limit was never the lens.
It was that looking costs the thing you're looking at ↓
Codio retweeted
A hardware team now ships the simulated version of a chip months before the silicon, and the software is finished when the die arrives
Most product timelines are serial, the chip taped out, then boards, then firmware, then the discovery that the software needed something the silicon can't do.
They cut that order by generating a cycle-accurate model of the chip the moment the spec exists, so every other team builds against it instead of waiting:
> Spec: the architecture is written once, as the single source for both paths
> Model: a cycle-accurate simulation is generated from it, not hand-written later
> Build: firmware and drivers are developed and tested against that model
> Reconcile: every spec change regenerates the model, so the two never drift
• What building against a model catches early
> A driver that needs an interrupt the architecture never allocated
> Timing assumptions in firmware that the real pipeline won't honour
> Features the software team assumed existed and nobody had specified
• Why generating the model matters more than having one
> A hand-written simulator is a second interpretation of the spec, and it diverges
> Regeneration means the model is never a stale copy of last quarter's design
> A disagreement between model and silicon becomes a spec bug, not a blame meeting
• What this does to the schedule
> Firmware is in test before the first wafer exists
> Bring-up stops being a three-month archaeology project
> A spec change costs an afternoon instead of a quarter of rework
The full model regenerates from the spec in about 20 minutes.
And the part that broke my brain:
The old timeline found software-hardware mismatches during bring-up, after tapeout.
This team found eleven of them four months before anything was manufactured.
Same chip. One version discovers the conflict when it costs a respin.
The bottleneck was never fabrication.
It was everything that could only start once it finished ↓
A hardware team now ships the simulated version of a chip months before the silicon, and the software is finished when the die arrives
Most product timelines are serial, the chip taped out, then boards, then firmware, then the discovery that the software needed something the silicon can't do.
They cut that order by generating a cycle-accurate model of the chip the moment the spec exists, so every other team builds against it instead of waiting:
> Spec: the architecture is written once, as the single source for both paths
> Model: a cycle-accurate simulation is generated from it, not hand-written later
> Build: firmware and drivers are developed and tested against that model
> Reconcile: every spec change regenerates the model, so the two never drift
• What building against a model catches early
> A driver that needs an interrupt the architecture never allocated
> Timing assumptions in firmware that the real pipeline won't honour
> Features the software team assumed existed and nobody had specified
• Why generating the model matters more than having one
> A hand-written simulator is a second interpretation of the spec, and it diverges
> Regeneration means the model is never a stale copy of last quarter's design
> A disagreement between model and silicon becomes a spec bug, not a blame meeting
• What this does to the schedule
> Firmware is in test before the first wafer exists
> Bring-up stops being a three-month archaeology project
> A spec change costs an afternoon instead of a quarter of rework
The full model regenerates from the spec in about 20 minutes.
And the part that broke my brain:
The old timeline found software-hardware mismatches during bring-up, after tapeout.
This team found eleven of them four months before anything was manufactured.
Same chip. One version discovers the conflict when it costs a respin.
The bottleneck was never fabrication.
It was everything that could only start once it finished ↓
Anthropic's team pointed a galaxy survey pipeline at Earth, and the planet turned out to be the harder target
Astronomy spent decades learning to pull a signal out of almost nothing, faint, noisy, distant, and Earth observation never needed those tricks because the ground is close and bright.
That turned out to be the problem, close and bright means every pipeline throws away the weak signal it doesn't think it needs:
> Borrow: the deconvolution and stacking methods built for faint galaxies come over
> Apply: the same maths runs on terrestrial passes instead of deep sky frames
> Recover: detail the standard pipelines discarded as noise comes back out
• What galaxy methods see that Earth pipelines don't
> Surface texture below the sensor's rated resolution, recovered not invented
> Slow change across years, separated from seasonal noise the way variable stars are
> Faint thermal structure that normal processing flattens into a single value
• Why nobody crossed the two fields
> Astronomers optimise for photons they can't get more of
> Earth imaging assumes another pass is always available tomorrow
> Both are right, and only one of them learned to waste nothing
One region reprocesses through the astronomy pipeline in about 15 minutes.
And the part that broke my brain:
The methods that let us resolve structure in galaxies billions of light years away sat unused on the one planet we have.
Same data. One field never had the luxury of discarding a frame.
The limit was never how close you are.
It was whether you learned to look when you couldn't be ↓
Codio retweeted
A team of software engineers wrote a script that designs the chip and then installs itself into the fab flow
Most silicon tooling stops at a file an engineer has to carry downstream by hand, which is why a design change takes a week to reach the people cutting masks.
Their script reads the data and does both ends, it generates the layout from field telemetry and pushes the verified result into the production flow itself:
> Ingest: failure reports, thermal logs and return data from deployed chips go in
> Generate: the floorplan is solved against what the field actually did to the last one
> Verify: timing, power and aging checks run automatically on every candidate
> Install: the passing design is written into the fab flow, no manual handoff
• What field data changes about the design
> Margin goes where returns came from, not where the spec assumed
> A block that overheated in deployment gets moved, not just warned about
> Every revision inherits the failures of the one before it
• Why installing itself is the real unlock
> The week between a verified design and a fab-ready one disappears
> Nobody retypes parameters between four tools and introduces a mistake
> A rollback is one command, because the install was scripted in the first place
• Where humans stay in the loop
> Tapeout needs a signature, always
> Safety and compliance blocks are reviewed by engineers, never auto-installed
> The script reports what it changed and why, before anything moves
A full generate-verify-install cycle runs in about 35 minutes.
And the part that broke my brain:
The old loop took a quarter to get field failures back into a design.
The script closed it overnight, and the next revision was shaped by the last one's returns.
Same silicon. One process learns from the field a year too late.
The hard part was never designing the chip.
It was getting what you learned back into one ↓
A team of software engineers wrote a script that designs the chip and then installs itself into the fab flow
Most silicon tooling stops at a file an engineer has to carry downstream by hand, which is why a design change takes a week to reach the people cutting masks.
Their script reads the data and does both ends, it generates the layout from field telemetry and pushes the verified result into the production flow itself:
> Ingest: failure reports, thermal logs and return data from deployed chips go in
> Generate: the floorplan is solved against what the field actually did to the last one
> Verify: timing, power and aging checks run automatically on every candidate
> Install: the passing design is written into the fab flow, no manual handoff
• What field data changes about the design
> Margin goes where returns came from, not where the spec assumed
> A block that overheated in deployment gets moved, not just warned about
> Every revision inherits the failures of the one before it
• Why installing itself is the real unlock
> The week between a verified design and a fab-ready one disappears
> Nobody retypes parameters between four tools and introduces a mistake
> A rollback is one command, because the install was scripted in the first place
• Where humans stay in the loop
> Tapeout needs a signature, always
> Safety and compliance blocks are reviewed by engineers, never auto-installed
> The script reports what it changed and why, before anything moves
A full generate-verify-install cycle runs in about 35 minutes.
And the part that broke my brain:
The old loop took a quarter to get field failures back into a design.
The script closed it overnight, and the next revision was shaped by the last one's returns.
Same silicon. One process learns from the field a year too late.
The hard part was never designing the chip.
It was getting what you learned back into one ↓
Anthropic's research team got sub-metre detail out of satellites that can't resolve sub-metre, by stacking twenty years of passes
Most imagery work treats each pass as a photo and picks the sharpest one, which throws away thousands of other looks at the same ground.
Nothing here is sharpened, the detail is accumulated, every pass contributes the slightly different piece of the scene it happened to catch:
> Align: twenty years of passes are registered to the same ground frame
> Stack: sub-pixel offsets between them are solved, not averaged away
> Separate: what changed between passes gets modelled apart from what didn't
• What falls out of stacking instead of sharpening
> Permanent structures resolve far below the sensor's rated limit
> Anything that moved is isolated automatically, because it didn't stack
> You can scrub the same patch of ground backwards through two decades
• Why nobody did this before
> It needs every pass co-registered, which was a job nobody could afford
> The old pipelines deleted the "worse" frames to save storage
> The information was never missing, it was scattered across the archive
One region resolves from its full twenty-year stack in about 12 minutes.
And the part that broke my brain:
The sensor's spec sheet says it cannot see anything under a metre.
Stacked across 2,000 passes, the same sensor resolves things a third of that.
Same satellites. One version only ever looked at one photo at a time.
The limit was never the resolution.
It was throwing away every frame but the best one ↓
Codio retweeted
Chinese technologists built the board that routes a robot's movement, and it logs every motion the robot decided against
Most robot controllers record what the machine did, so a failure review shows you a clean path and nothing about the three worse paths it nearly took.
Their board keeps the rejected branches, every alternative the planner scored and dropped, written to silicon before the motor ever moves:
> Plan: each cycle generates several motion candidates, not one command
> Score: every candidate carries its cost, risk and clearance margin
> Route: the winner goes to the motors, the losers go to the log
> Trace: the chip timestamps all of it at the microsecond, on-board
• What the rejected branches reveal
> A near-collision the robot avoided by 2mm that nobody knew happened
> A joint that keeps almost exceeding its limit under one specific load
> Drift in the scoring itself, where safe options start losing to fast ones
• Why logging the discards changes robotics
> A clean run and a run that nearly killed someone look identical in normal logs
> Safety margin becomes a measurable number instead of an assumption
> You can audit a decision, not just replay a trajectory
• Why this has to live on the chip
> The alternatives exist for microseconds, no network call is fast enough
> Off-board logging drops exactly the cycles that matter most
> The log survives even when the robot doesn't
One board holds about 40,000 scored decisions per second of operation.
And the part that broke my brain:
A fleet of these ran six months with zero recorded incidents.
The discard logs showed 412 moments where the second choice would have hit someone.
Same robots. One version calls that a perfect safety record.
The risk was never in what the robot did.
It was in how close it came to doing something else ↓
Chinese technologists built the board that routes a robot's movement, and it logs every motion the robot decided against
Most robot controllers record what the machine did, so a failure review shows you a clean path and nothing about the three worse paths it nearly took.
Their board keeps the rejected branches, every alternative the planner scored and dropped, written to silicon before the motor ever moves:
> Plan: each cycle generates several motion candidates, not one command
> Score: every candidate carries its cost, risk and clearance margin
> Route: the winner goes to the motors, the losers go to the log
> Trace: the chip timestamps all of it at the microsecond, on-board
• What the rejected branches reveal
> A near-collision the robot avoided by 2mm that nobody knew happened
> A joint that keeps almost exceeding its limit under one specific load
> Drift in the scoring itself, where safe options start losing to fast ones
• Why logging the discards changes robotics
> A clean run and a run that nearly killed someone look identical in normal logs
> Safety margin becomes a measurable number instead of an assumption
> You can audit a decision, not just replay a trajectory
• Why this has to live on the chip
> The alternatives exist for microseconds, no network call is fast enough
> Off-board logging drops exactly the cycles that matter most
> The log survives even when the robot doesn't
One board holds about 40,000 scored decisions per second of operation.
And the part that broke my brain:
A fleet of these ran six months with zero recorded incidents.
The discard logs showed 412 moments where the second choice would have hit someone.
Same robots. One version calls that a perfect safety record.
The risk was never in what the robot did.
It was in how close it came to doing something else ↓