Webcaster LTD · independent R&D · embodied intelligence
Aliveness is an architecture problem.
We build machines that read as alive, on hardware a person can afford, running entirely in the room where they live. The difference isn't a bigger model. It's a different loop.
A system that computes only when it's polled can never feel alive, at any parameter count. One running a continuous predictive loop can, on modest hardware.
Same body · same sensor · same target · different loop
The blind spot
The industry is building the display layer.
Talking, reasoning and answering are the parts of ourselves we can introspect on, so they're what got written into the specification of "intelligence." The machinery that actually makes something feel alive was never specified, because it never made it into our description of ourselves either.
Reaching for a cup feels like nothing, so it gets modelled as nothing. It isn't nothing. Most of the brain's neurons sit in the cerebellum, which coordinates movement. The entire cortex, where reasoning and language live, has under a fifth of them.
This is why movement is still unsolved: the field is attacking it with tools built for text and images. The expensive path became the default, and the cheap one has barely been explored.
Azevedo et al., 2009
The old skills are the hard ones. Moravec's paradox has held up very well.
The unclaimed ground
Nobody scores whether it reads as alive.
The field benchmarks task success rate. Nobody measures whether a machine reads as alive, so nobody optimises for it. This space hasn't been tried and failed. It has mostly never been attempted.
Our reference failure is the wall-avoiding hobby car that moves like a drunken blind man. Everything dead about it comes from the shape of its loop. None of it comes from the hardware.
Reacts inside ~100 ms
Fast enough that the reaction reads as noticing, not processing.
latency < 100 msMoves continuously
There is no sense → threshold → act cycle. Motion flows instead of being a string of separate decisions.
no discrete stepsCarries biological noise
Nothing alive moves in a straight line with a trapezoidal velocity profile, and nothing alive holds perfectly still.
noise σ > 0Directs attention visibly
It looks at the thing it's dealing with before it moves toward it.
gaze leads bodyAnticipates
It gets into position before something happens instead of reacting afterwards.
acts before the eventIdles when untasked
With nothing to do, it still does something.
untasked ≠ stillRemembers the first time
Its second encounter with something is different from its first.
encounter 2 ≠ 1
All seven are running on the red robot's floor at the top of this page.
Why it can be small
Cheap in compute. Expensive in design.
Living in a house is a domain of expertise like any other, and expertise turns out to be small. Measured across very different fields, it comes to tens of thousands of recognised patterns, not billions.
Counted room by room, a household comes to roughly ten to twenty thousand things worth recognising. A local machine can hold a working set that size outright. That's why we don't need a datacenter, and why we refuse to depend on one.
Jōyō kanji list (2010) · Jenkins et al., 2018 · Brysbaert et al., 2016 (lemmas) · Simon & Gilmartin, 1973 · household: Webcaster estimate
The test
Falsifiable with two motors and one sensor.
If aliveness comes from architecture rather than capability, it has to show up at the smallest possible scale: a two-wheeled robot either moves like something or it doesn't. That costs tens of euros and a few days. If it doesn't show up there, no amount of compute will rescue it, so we won't buy a bigger platform until it does.
Purpose
Nobody should die alone.
We're building toward a companion that observes around the clock, learns habits and never interrupts. It answers when asked. Once in a while, by exception, it speaks first.
Never interrupting removes most of the hard problems.
There's no engagement loop, no notifications, and no guessing whether now is a good moment.
The first useful version needs no hands.
It needs perception, memory and a voice. Dexterous manipulation is the genuinely unsolved problem, and it isn't on the critical path.
"Where are my glasses?" comes first, not last.
Knowing what is where is the first thing this architecture is good at, so it's where the product starts.
Approached from the other end, the same specification is a toy. A child among adults and someone living alone are missing the same thing, and in neither case is the missing thing more presence.
Non-negotiables
Local is the design, not a setting.
Nothing leaves the room.
A robot that has to reach a datacenter to think is a sensor with an uplink. Privacy isn't a feature layered on top. It's what the architecture is.
Train once, centrally. Run locally.
Training is paid for once and spread across every unit. What ships are the weights, and they run with no connection.
Hardware a person can afford.
The whole bet is that aliveness is cheap in compute. Building on scarce premium hardware would concede the point before we started.
Nothing to discontinue.
Something that lives in your room for years can't depend on a service that can be repriced or switched off.
How we get there
A chain of enablers, not one moonshot.
Each link ships on its own and is useful on its own. That's what lets a small team build this over years, instead of betting everything on a moonshot that has to land whole.
A nervous system that ignores motor noise
Signalling that can sit centimetres from motor drivers with no interference, no ground loops and a lighter harness.
Memory that merges without a committee
What one machine learns can combine with what another learned, with nothing agreed in advance. It works the way Linux does: patches get merged, and no standards body is needed.
Meaning that arrives whole
One signal carries a whole meaning, so there's nothing to parse and nothing to wait for.
Language models as the compiler, not the runtime
Open models do the naming once, offline, and then step out of the loop. What runs in the room is small, fast and yours. It's a bridge from language models to hardware that anyone can use.
On the bench
The first boards are routed.
The first two boards of the signalling layer are designed, routed and pass design-rule checks. We generate the layouts from code in-house, so changing the design means re-running it, not redrawing it. Fabrication files, bill of materials and placement data are ready.
Both layouts are shown at the same scale. Each colour is a copper layer.
Done
- Thesis and architecture written down
- Signalling boards designed, routed and DRC-clean, with fab outputs generated
- Base-station compute already on hand
Next
- Fabricate and bring up both boards
- Run the two-motor test
Later
- The first companion: perception, memory and a voice, with no hands
Funding
Tiny company. Giant goal.
Webcaster LTD is raising early funding to get these boards onto the bench, run the two-motor test and build toward the first companion. We'd rather show than tell, so technical briefings are available under NDA.