ExpertsFMRobot-Use Agents: Why General-Purpose Models May Win in Robotics
Y Combinator Startup Podcast · September 26, 2026
5 Selected Lessons:
heuristic · 2 case · 1 reasoning_pattern · 1 priority · 1
Prediction: general-purpose, teenager-level robots within roughly two years
Source
Y Combinator Startup Podcast — Robot-Use Agents: Why General-Purpose Models May Win in Robotics (September 26, 2026) · at 26:05 ▸
When this applies
when trying to gauge industry-wide readiness/timing for a major capability threshold that insiders see coming but the public does not
The takeaway
When multiple independent frontier players converge on the same timeline estimate for a capability threshold, treat that as a stronger signal than any single actor's claim, even though it remains an unverified prediction.
Why it works
Converging signals from multiple frontier labs and foundation model companies (internal roadmaps, observed capability jumps, platonic representation convergence) lead insiders to a shared estimate that outsiders, lacking that visibility, underestimate.
One level up
Industry insiders often see capability inflection points coming well before the broader public or market has priced them in.
Where it stops holding
This stops working when the 'consensus' is actually driven by shared optimism bias or market incentives among insiders rather than independent technical signal, or when unresolved bottlenecks (e.g. latency, hardware) take longer to resolve than expected.
Detail
hierarchy:
- General-purpose robots matching a competent teenager's bare-hand capability across unseen tasks/environments — predicted within two years or earlier
- This is society's current blind spot — considered more imminent and more disruptive than broadly understood
rationale: Analogous to the 'ChatGPT moment' for language, but for physical capability generalization.
In their words
There's some consensus within the Frontier Labs and also in the Robotics Foundation models companies that we will have general purpose robots within the next two years or even earlier. And this is something that society is probably unaware of or even unprepared for.
Prefer a strong general-purpose model over a narrow specialized one when representations converge
Source
Y Combinator Startup Podcast — Robot-Use Agents: Why General-Purpose Models May Win in Robotics (September 26, 2026) · at 4:12 ▸ · at 19:13 ▸
When this applies
when deciding whether to build a narrow specialist system or to adapt a strong generalist system for a new vertical task
The takeaway
If two systems are converging toward the same underlying representation of reality, investing in the stronger, more broadly-trained one will eventually beat a weaker system built narrowly for one use case.
Why it works
If the generalist model's learned representation of the world already overlaps with what the specialist task needs (per the Platonic Representation Hypothesis), then improving the generalist automatically improves performance on the specialist task, compounding gains from all the data poured into it across many domains.
One level up
Bet on broad capability-building whose benefits compound across many future unknown applications over narrow optimization for one known application.
Where it stops holding
This stops working when the specialist domain requires distinct, non-overlapping structure that general training data cannot supply, or when the generalist's latency/cost makes it unusable for the task.
Detail
approach: Ask whether the general model's internal representation of the world is converging with what the specialist task needs; if so, invest in making the general model stronger rather than building a narrow specialist.
signals:
- evidence that different training regimes converge to similar representations (Platonic Representation Hypothesis)
- the specialist task already benefits from general pretraining data (e.g. coding, computer-use data)
- narrow specialist data is scarce or bottlenecked
rationale: A single strong generalist model regardless of architecture will outperform a slightly weaker specialist model, per the Bitter Lesson taken to its 'best manifestation.'
In their words
Using if we believe in the platonic representation hypothesis, and if that's true, then Bitter Lesson is that is the best manifestation of the BitterLesson, right? Because you just need one really strong model, regardless of architecture, and they would be outperforming any specific models that is slightly weaker.
Use deterministic code for repetitive subtasks, reserve the slow general model for variation points
Source
Y Combinator Startup Podcast — Robot-Use Agents: Why General-Purpose Models May Win in Robotics (September 26, 2026) · at 16:00 ▸
When this applies
when building any agentic pipeline where parts of the task are highly repeatable and other parts require flexible judgment
The takeaway
Reserve your most expensive/slowest reasoning capacity for genuine decision points, and automate the predictable parts of a pipeline with fast deterministic logic.
Why it works
Invoking a large, slow general model (e.g. Astra) at every single step incurs high latency and cost; writing deterministic code for repetitive/predictable subtasks and inserting a smaller model (e.g. a VLM) only at genuine points of variation (object detection, failure handling) balances speed against flexibility.
One level up
Allocate your scarcest, most expensive resource (compute, expert judgment, latency budget) only at points of real uncertainty, not uniformly across every step of a process.
Where it stops holding
This stops working when it's hard to reliably identify in advance which steps are truly deterministic versus which secretly require judgment, leading to brittle failures when 'deterministic' code hits an edge case.
Detail
rule: Convert repetitive, well-understood subtasks into deterministic code; keep a VLM/general model in the loop only at points of variation such as object detection or failure recovery.
threshold: any subtask performed 'quite a few times' with predictable structure is a candidate for code; failure-detection and novel situations stay with the flexible model
rationale: Repeated invocation of the slow general model for every micro-step is not economically useful due to latency; a deterministic graph with embedded flexibility points preserves generalization without full-cost reasoning at every step.
In their words
If it's a repetitive task, you don't want Astro in the loop. Maybe you want to write code that can run repeatedly very, very fast. Or if it's a task you've done a similar task before, you should be able to call a skill that has compiled and use that skill to do the task faster and handle edge cases better.
Fable-class LLM latency doubling in speed monthly as a timeline predictor
Source
Y Combinator Startup Podcast — Robot-Use Agents: Why General-Purpose Models May Win in Robotics (September 26, 2026) · at 16:00 ▸
When this applies
when forecasting when a currently-too-slow capability will become fast enough for real-time/production use, given a measured improvement rate
The takeaway
Use a measured exponential improvement rate in a currently-limiting bottleneck to project forward a rough timeline for when that bottleneck stops being limiting.
Why it works
If a measured rate of improvement (e.g. 2x latency reduction per month) continues, you can extrapolate forward to estimate when a threshold of usability (real-time control) will be crossed.
One level up
When a capability is currently blocked by one measurable bottleneck improving at a known rate, timeline-forecast off that rate rather than off vaguer intuition.
Where it stops holding
This stops working when the improvement rate is a short-term trend that doesn't hold — e.g. if gains plateau due to fundamental hardware or architectural limits.
Detail
rule: Fable-class LLM latency has been improving at roughly 2x per month; if this continues, real-time robot control could be reached by end of year.
threshold: 2x per month improvement rate
rationale: Current demos are bottlenecked by model latency (Astra-in-the-loop), but the observed trend suggests this bottleneck resolves soon.
In their words
So, one thing that we saw is that for Fable-class LLMs, their latency is improving by around 2x per month, which is very, very fast. Very fast. If the trends continue, we could get real-time control by end of the year.
RT2: pretraining on web data beats robotics-only training
Source
Y Combinator Startup Podcast — Robot-Use Agents: Why General-Purpose Models May Win in Robotics (September 26, 2026) · at 0:00 ▸ · at 4:12 ▸
When this applies
when building a specialized model for a narrow task, deciding whether to train from scratch on in-domain data or adapt a model already pretrained on a much larger, broader dataset
The takeaway
Transferring a capability from a data-rich adjacent domain can beat training directly on scarce in-domain data, because the pretrained model brings inductive structure the narrow dataset can't supply alone.
Why it works
A model pretrained on massive general data has already learned transferable structure (e.g. spatial, causal relationships) that a narrow in-domain dataset is too small to teach on its own; fine-tuning taps into that pre-existing representation.
One level up
When data is the bottleneck in your target domain, look for a larger adjacent domain whose representations overlap with what you need, rather than trying to force progress with too little direct data.
Where it stops holding
This stops working when the adjacent domain's learned representations don't actually overlap with what the target task requires, or when enough in-domain data exists to make transfer unnecessary.
Detail
situation: Robotics models trained purely on robot data were data-bottlenecked; RT2 instead fine-tuned a language model pretrained on web text and images to output robot action poses.
decision: Researchers chose to adapt a general pretrained model rather than train a robotics-specific model from scratch.
outcome: RT2 outperformed robotics foundation models that lacked this web pretraining, because it tapped into the broader modality of data the language model had already learned.
lesson: Fine-tuning a model pretrained on abundant adjacent data can beat training narrowly on scarce target-domain data.
In their words
So, all those web images and web text actually improves the VLA compared to just training a specific robotics foundation model without any pre-training.