← Back to Blog

How to deploy your first 1,000 robots

The teams that reach 1,000 robots make every failure fix every robot. Here is the playbook: team structure, data infrastructure and the learning loop.

A human hand reaches toward a robot hand, with many robot arms and a drone behind it, in the style of a Renaissance fresco

By Joe Harris, Founder and CEO of Alloy. 4 November 2026.

The short answer. To reach 1,000 robots, your fleet has to grow faster than your team. That takes three layers. A support team split into tiers so tickets close before they reach engineering, data infrastructure that gets every run off every robot into one searchable store, and a learning loop that turns every fixed failure into a test so it never comes back.

Key takeaways

  • Robots per support person is the number to watch. If it stays flat as the fleet grows, you are scaling by hiring.
  • Split support into L0 to L3 tiers. Protect core engineering (L3) so it only gets root-caused tickets.
  • Record every fix in a knowledge base everyone can read. Note the symptom, root cause, fix and how to spot it next time.
  • Upload every run automatically, store it as MCAP in one cloud bucket, and make the fleet queryable with SQL.
  • Turn every fixed bug into a test that runs on every new log. That is how each failure gets fixed once for the whole fleet.

Why do robotics teams stall before 1,000 robots?

The engineering shortage is real, and robotics teams need more great engineers.

But if every new batch of robots needs more engineers to keep it running, your cost per robot never falls, and the unit economics don't scale. That's one side of what Oliver Hsu calls the deployment gap.

The teams that reach 1,000 robots make every failure fix every robot.

Below are three layers we've seen from working with robotics teams across agriculture, defence, maritime and humanoids, with more than 1,000 robots now being analysed by Alloy. Get these right, and your fleet can grow faster than your team.

How should you structure your team as the fleet grows?

A field engineer at a fast-growing robotics company told my team that he maxes out at 4 to 5 sites. To keep growing to their next stage, every person like him needs to handle 15 to 20.

That ratio, sites or robots per person, decides whether you reach 1,000. If it stays flat as you grow, you're scaling by hiring.

Most fleets move through three stages.

  1. Expensive teleop. A robotics engineer goes out with every robot.
  2. Cheap teleop. A trained operator goes out instead.
  3. Customer operations. The customer runs the robot themselves.

Each stage needs fewer of your best engineers per robot. The trap is tickets.

Most robotics teams start off with a team of cracked generalist roboticists. These are your golden eggs, and you want to keep these people focused on the highest-leverage work (typically R&D).

But as the fleet grows, your robots will run into issues. Then you have a new category of work, tickets. This work has four traits.

  • Urgent
  • Revenue-critical
  • Dependent on an intimate understanding of the robot
  • But low leverage

So tickets often pull your best engineers off the core roadmap.

Even when you hire, the juniors still have to ask your seniors for help, because the tribal knowledge needed to resolve a ticket end to end is very high. Now your seniors are training the juniors and resolving the tickets, so they have even less time.

Here is how to structure the team so it can handle a growing fleet while it keeps R&D first. The tiers are how you move from stage 1 to stage 3.

Left: tickets from every robot go straight to three senior engineers, and the R&D roadmap is on hold. Right: tickets flow through L0 agent triage, L1 customer success, L2 support and field engineers, then L3 core engineering, with fewer tickets at every layer, and R&D gets full focus.

Split support into L0, L1, L2 and L3

This is what frontier teams have converged on.

  • L0. An agent triages every ticket, pulls the robot's data and answers the known issues before a human sees them.
  • L1. Customer success handles intake and known fixes from the runbook.
  • Field engineers. The hands on the robot, on site alongside L1 and L2.
  • L2. Technical support digs through logs and reproduces the issue. At volume, split it into hardware and software.
  • L3. Core engineering. It only gets root-caused tickets.

In the teams we've seen, most tickets close before engineering. One team with 50 to 125 tickets a week sends about 5 to 10 to engineering.

Hire in this order.

  1. A field deployment engineer first, so field issues stop routing straight back to R&D.
  2. Then L1.
  3. Then L2, split by hardware and software.

Protect L3, and put Alloy under all of it so every new hire covers more robots.

Alloy works across every tier. It takes the first response, gives L1 and field engineers the fix from past cases, runs root cause for L2 with every finding linked to its evidence, and only hands engineering the tickets that need them. It also reviews every new run, so issues get caught before anyone files a ticket.

Make every engineer your best engineer

Build a knowledge base everyone can read. It can be as simple as a folder of markdown files, logs and past tickets. With Alloy, every investigation writes to the knowledge base, so it builds itself as your team works.

  • Record every fix. Symptom, root cause, fix and how to spot it next time, linked to its runs and ticket.
  • Give everyone access. Support, field techs and ops pull answers themselves instead of pinging an engineer.

This reduces key-person risk if one of your engineers leaves, and it makes training new hires a lot easier.

Which metrics show your team is scaling?

  • Robots per support person. The headline number. It should rise as the fleet grows.
  • First-line resolution rate. The share of tickets closed at L0 or L1 without escalating. SwarmFarm went from about 30% to about 80% with Alloy.
  • Time to resolve. SwarmFarm support went from 1 to 2 hours to about 10 minutes per ticket.
  • Tickets reaching engineering. Push it down and R&D stays on the roadmap.
  • Repeat-failure rate. How often a fixed issue comes back. It should trend to zero once every fix ships with a regression test.

Get this right and each failure gets fixed once, for the whole team. But a team can only learn from data it can see.

What data infrastructure does a 1,000-robot fleet need?

A teetering stack of robot data tools, from onboard logs up to telemetry tables, replay, ML training and agents, all resting on one cron job that rsyncs logs off each robot, written by an engineer who left in 2024. After xkcd 2347.

You can't search the fleet for a failure you never uploaded. So before anything else, you need a reliable, scalable way to get every run off every robot.

Bell-curve meme. Both ends say put the logs in one bucket and let agents query them. The middle wants a custom log format, Kafka, a lakehouse, a feature store, a vector database and a 12-person data platform team.

Frontier teams like AdNav, SwarmFarm and Andromeda all run a version of this stack. It's also the stack Alloy runs for you.

1. Upload every run automatically

  • An always-on edge agent uploads every finished run. It is outbound only, so it works behind NAT, on LTE or through a base station.
  • No SSH, rsync or USB sticks.
  • Each robot enrols once and is configured from the cloud.
  • Runs reach the cloud before the ticket does, so issues get fixed faster. Logs no longer expire on the robot.

2. Store every run as MCAP in one cloud bucket

  • Default to the cloud, so every engineer, field tech and agent reads the same runs. A NAS can buffer data on the way (depot, base station), but not store it long term.
  • Security and data sovereignty don't change the architecture. Use your own VPC or region, or on-prem MinIO.
  • Use S3-compatible storage. It is cheap, effectively unlimited and no lock-in. Alloy Storage gives you this with zero egress fees, or you can bring your own bucket (R2, MinIO, Backblaze B2).
  • MCAP holds every stream from a run in one file, on one clock. It replaces ROS bags, CAN dumps, CSVs, and separate video and text logs.
  • MCAP works with the tools you already use (Foxglove, Rerun, Python, agents). It's indexed, so you can pull one robot's camera for two minutes without downloading the whole file.

3. Make the fleet queryable

  • Decode the low-rate telemetry once into columnar SQL (ClickHouse, Parquet on DuckDB, BigQuery). Cameras and LiDAR stay in the MCAP.
  • Fleet-wide questions take one query and seconds. For example, which robots threw this fault last week, and on which firmware?
  • The fleet view shows how often and where a problem happens, which sets the roadmap.
  • The MCAPs stay the source of truth, so you can rebuild the tables at any time.

Now every failure is searchable. The last step is making sure each one only happens once.

How do you stop robots making the same mistake twice?

A loop around a cat. A robot breaks. It turns out 40 other robots broke the same way. Fix it once, for every robot. Now I can deploy more robots.

We believe three things.

  • Robots should learn from every mistake they make.
  • Robots should not make the same mistake twice.
  • More robots = more mistakes to learn from = more reliability.

This view is simple, yet surprisingly contrarian. Most companies do the opposite.

  • A robot fails, an engineer pulls its logs, fixes it and closes the ticket.
  • The root cause gets explained in a Slack thread.
  • When tickets pile up, you hire another support engineer.

What is the learning factor?

Every new robot brings failures either way. What changes is whether each one gets fixed once for the whole fleet.

fₙ = f₀ · (1 − ℓ)ⁿ

  • f₀ = your failure rate today
  • fₙ = your failure rate after n more robots
  • ℓ = learning factor, or how much each robot's failures teach the whole fleet

If ℓ = 0.01, then 0.99³⁶⁵ ≈ 0.03. After 365 robots, each robot fails 97% less, so the same team supports a much bigger fleet.

If ℓ = 0, then 1³⁶⁵ = 1. Reliability doesn't get worse, it just never gets better. The same team tops out at a fixed fleet size, and the only way to grow is to hire.

It's the same concept as in Atomic Habits, applied to robotics.

The whole game is getting ℓ above zero. It's also the hardest part.

Chart of money over time with the same team. A fleet that keeps learning grows without limit at the same team size. A fleet that does not learn flattens out, because you can only deploy so many robots before you have to hire more.

The labs are attacking it from the model side. You can attack it from the fleet side today. Once you have proper data infrastructure, you can pool your corpus and get the learning gains from it.

Tesla and Waymo have done this very well. They spent a decade and billions building their loops in-house, and teams still spend millions a year trying to copy them. Every car they deploy makes all the cars more reliable. They know exactly what this loop is worth. That's why senior leaders at both companies are angel investors in Alloy.

When Tutor raised $75M, its CEO said, "Solving robot intelligence doesn't mean solving robotics." Solving robotics is the long game.

The loop we run with our customers

1. Triage every failure in one queue, and weight all sources equally.

Failures arrive from four sources. They are engineer observation and internal validation, automated alerts, operator reports and customer reports. Most teams only act seriously on the last one. Frontier teams detect and triage all four in one queue. The goal is to catch these issues before a customer has to report them.

2. Search the fleet before you reproduce a bug.

The default move is to reproduce the failure on a test robot. That costs days, and sometimes it fails to trigger the bug. The fleet has usually reproduced it already, so search fleet data for other instances first. That is how Andromeda went from one swerving robot to a bad batch of wiring harnesses.

3. Test that every fixed bug stays fixed.

This is how you make ℓ positive. A bug you fix but never test for will come back. Once it's fixed, turn the bug's signature into a test that runs on every new log. If it shows up again, you know straight away, instead of solving it from scratch.

Why does robots per person decide who wins?

None of this is secret, and most of it feels obvious once it's written down. The hard part is getting this system to work before you run out of cash.

In software, every $1 of revenue carries about 10c of headcount. In physical industries like farming, mining, logistics and manufacturing, it's 70 to 90c. That's why AI in the physical world is the bigger opportunity, and why robots per person is the number that decides who wins.

Every robotics company has a learning factor. What gets measured gets managed, and you can't measure yours without the data. So getting your data infrastructure right from the start is P0.

This is the loop Alloy runs for robotics teams. We built the world's first AI robotics engineer. Across our partners, investigations that took weeks now take as little as a day, and field-issue response time is down by up to 50%.

FAQ

What is the deployment gap in robotics?

The term comes from Oliver Hsu. One side of it is this. If every new batch of robots needs more engineers to keep it running, your cost per robot never falls, and the unit economics don't scale.

What is the most important metric for scaling a robot fleet?

Robots per support person. It should rise as the fleet grows. If it stays flat, you are scaling by hiring.

Who should a robotics company hire first for fleet support?

A field deployment engineer, so field issues stop routing straight back to R&D. Then L1 (customer success), then L2 technical support split by hardware and software.

Why store robot data as MCAP?

MCAP holds every stream from a run in one file, on one clock. It works with Foxglove, Rerun, Python and agents, and it is indexed, so you can pull a short window of one stream without downloading the whole file.

How do you stop a fixed robot bug from coming back?

Turn the bug's signature into a test that runs on every new log. If it shows up again, you know straight away.


This article was first published on X by Joe Harris on 4 November 2026. Read the original post on X.

See what Alloy can do with your robot data

Book a demo to see how Alloy works with your data.

Book a demo