Simulation environments for verifying mission critical software. Backed by @ycombinator and @solofounders
Simulation
Joined June 2025
- Tweets64
- Following4
- Followers1.1K
- Likes217
Pinned Tweet
Introducing Workers IO
Agents are making it possible to turn ideas into software faster than ever. To keep up with that, we need better ways to understand how our software will behave in real-world.
Workers IO runs your entire system through millions of simulated futures, exploring what happens when machines fail, networks slow down, and events arrive in the wrong order. It searches for the combinations that break your system before your customers encounter them.
Every failure it encounters is perfectly reproducible, helping teams understand what happened, work on a fix, and verify against the same scenario.
This ability changes what teams are willing to take on. Difficult engineering decisions become things that you can explore and verify.
That’s the future we’re working toward: small teams building increasingly ambitious systems, with the evidence to stand behind.
I can’t wait to see what you build with that confidence.
Workers IO retweeted
These are interesting times, we see agents hacking stuff and at the same time formally verifying oss software.
We are hosting a formal methods hackathon along with some of the best folks in this space including @theoremlabs
I’m super excited about all the things people are going to “vibecheck” at the event.
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
Workers IO retweeted
Internet really is falling apart, a year ago my @solofounders cohort and I first spoke about "fixing the internet"
The cracks are finally starting to show in a big way. Until now, teams could get away with sloppy engineering and poor security practices purely because the cost of compromising systems was super high.
That is no longer the case, now all it takes is a few tokens a single gap in your system for it to fall apart.
eMudra incident is not going to be the last one and it'll be irresponsible for teams to not have dedicated budget just for security and correctness of their systems.
@workersio will have a big part to play in this!
Workers IO retweeted
So many teams have traded understanding and safety for velocity.
They didn't have to, you really can have it all!
Workers IO retweeted
Anyone I know looking to try out a new DST product? they're small but have already closed a few interesting logos, seem to have a good product, and very very affordable
How to test for failures that only happen in production?
Most teams test their system in a perfect world. However, in production, packets get lost, machines crash and even disks fail.
To verify against these failures, you need a fault model: every part your system depends on, from the network, system calls, memory, disk, and the ways each one can fail. Writing one takes deep knowledge of every layer, and most teams never get to it.
At Workers IO, we build that fault model for you, then run your entire system through a different mix of failures every time. When things breaks, you get the exact scenario that caused it with perfect reproducibility.
What does it take to verify mission-critical software?
One of the most difficult things when it comes to testing complex systems is figuring out all the ways it can fail.
How your system can behave in production is not just limited to the code, you also need to look at the behavior of the infrastructure that it runs on and how your customers are using it.
At Workers IO, we’ve put a lot of work into a workload generator that turns this mental exercise into a compute problem.
Here’s how it works.
How to test for failures that only happen in production?
Most teams test their system in a perfect world. However, in production, packets get lost, machines crash and even disks fail.
To verify against these failures, you need a fault model: every part your system depends on, from the network, system calls, memory, disk, and the ways each one can fail. Writing one takes deep knowledge of every layer, and most teams never get to it.
At Workers IO, we build that fault model for you, then run your entire system through a different mix of failures every time. When things breaks, you get the exact scenario that caused it with perfect reproducibility.
Workers IO retweeted
Our workload generator just found a really interesting failure. It simulates people typing into many remote sessions at once, over a network it deliberately makes slow, lossy or out of order.
The system prioritizes what it sends, so the echo of a keystroke goes out ahead of a flood of logs. But when the network got slower after it connected, we kept sending at the old speed. The extra data piled up in the network, so every keystroke waited behind it and lagged by about half a second.
Most teams never write scenarios like this, let alone test against them. It's just a default for us :)
What does it take to verify mission-critical software?
One of the most difficult things when it comes to testing complex systems is figuring out all the ways it can fail.
How your system can behave in production is not just limited to the code, you also need to look at the behavior of the infrastructure that it runs on and how your customers are using it.
At Workers IO, we’ve put a lot of work into a workload generator that turns this mental exercise into a compute problem.
Here’s how it works.
Workers IO retweeted
formal verification is one of the underdeveloped fields in the modern tech, will probably be huge unlock for AI in mission critical software
What does it take to verify mission-critical software?
One of the most difficult things when it comes to testing complex systems is figuring out all the ways it can fail.
How your system can behave in production is not just limited to the code, you also need to look at the behavior of the infrastructure that it runs on and how your customers are using it.
At Workers IO, we’ve put a lot of work into a workload generator that turns this mental exercise into a compute problem.
Here’s how it works.
What does it take to verify mission-critical software?
One of the most difficult things when it comes to testing complex systems is figuring out all the ways it can fail.
How your system can behave in production is not just limited to the code, you also need to look at the behavior of the infrastructure that it runs on and how your customers are using it.
At Workers IO, we’ve put a lot of work into a workload generator that turns this mental exercise into a compute problem.
Here’s how it works.
Workers IO retweeted
One of the hardest things we do at @workersio is assigning a severity to a finding.
It’s a big responsibility because we must to do a better job than our customers.
If we downplay a finding it may end up getting deprioritized and lead to a more serious incident later on, but it’s also just as easy to annoy people if we overstate things.
The biggest advantage we have is, every finding is used to chain things and explore new behavior, makes this job a lot easier than looking at things in isolation.
