
I started this gangsta' shit. And this is the motherfuckin' thanks I get?
It’s what you reach for when the dashboards say everything is fine, but the system clearly isn’t. Or when the firewall, sandbox or gateway you need doesn’t exist yet, and you’d rather build it than wait for it.
It’s built for the engineers who build infrastructure. People who live in htop, write clever one-liners with awk, and still have iptables rules from 2014 they’re afraid to touch. More and more, it’s also built for the agents those same people hand a terminal to.
yeet gives you kernel-level primitives for security, observability and networking. You write a script in JavaScript, start it with yeet run, and that script can load eBPF programs, watch and filter traffic, read live system state, and show you whatever it finds in your terminal or your browser. It’s a good abstraction on top of the kernel’s BPF subsystem, so normal people (and models) can use it without sacrificing their sanity to its black magic.
When something’s broken, exposed, or just being weird, you don’t want to dig through five dashboards or file a ticket with the network team. You just want to ask:
For years the answer was a different product for every question: a firewall appliance, a service mesh, an observability vendor, a sandbox. yeet is the thing those products are made of.

yeet gives you the power to build the exact tool your question needs, on the machine where the problem is, and throw it away when you’re done.
yeet is not about collecting everything forever. It’s about getting the right data, right now.
Because when pagers start going off at 3am and your systems are melting, you don’t need another dashboard. You need answers.
None of the above. It’s a primitive.
Think about what docker run did. Mount namespaces landed in Linux 2.4.19 in 2002, and most developers didn’t touch them until Docker wrapped them in one command in 2013. That command made containers something everyone could build on. CI runners, dev containers and Kubernetes all stand on containers today. Docker didn’t build your CI pipeline. It gave you the piece you build it from.
eBPF has been in Linux since 3.18 in 2014, and it can see almost everything the kernel does: every syscall, every packet, the functions inside a running binary. It can also decide what happens next: drop a packet in the NIC driver, refuse a connection, deny a file read. But writing it means C, kernel headers, and a verifier that rejects your program and explains why in BPF assembly. So most people never touch it.
yeet run is the one command for eBPF. So don’t judge yeet by the tools that ship with it. Judge it by what you can build on top of it.

This is the part that lives on each host, quietly waiting for a script to tell it what to look at. It’s what you are installing when you type that good old curl -fsSL https://yeet.cx | sh into your terminal.
Here’s what it does:
tl;dr yeetd does the dangerous, boring part. It holds root, talks to the kernel, and cleans up after you, so your script only has to say what it wants to see.
yeet run)One-off tools are cool, until you need to run them somewhere else, change them, or hand them to a teammate. In yeet, every tool is just a script: a JavaScript or TypeScript file, an optional eBPF program, and yeet run to start it.
A script can:
And because it’s just a script, it runs anywhere yeet does. yeet run ./hot.tsx from a file on disk, or yeet run gh:yeet-src/exectop straight from GitHub.
You don’t have to write everything from scratch.
You don’t even have to know how eBPF works (unless you want to).
You just describe the tool you need, let your agent write it, and yeet run it.
tl;dr the kernel used to be a restaurant with one menu and a three-week wait. yeet run hands you the keys to the kitchen.
AKA Where the magic happens.
Here’s the kind of infrastructure the same primitive turns into once you start building on it:
agent-lock)httpwatch) or per-container traffic (container-traffic)Different layers of the stack, different jobs, same yeet run.
Discover yeet apps
browse allhttp requests served to your browser. Every plaintext HTTP request crossing the box — decoded off the wire by eBPF and rendered live in native browser components. No proxy, no sidecar, no app changes; one Docker command.
And here’s the best part:
tl;dr yeet enables you to be a one-person incident response team (two, if you count your agent). Like being John McClane, but for distributed systems spewing alerts. Yippee-ki-yay, on-call escalations.

Every layer of computing has gone this way. Namespaces became containers, and containers became what Kubernetes is made of. The DOM became React, and React became what agents reach for when they build a web app. A good primitive disappears into whatever gets built on top of it. We think eBPF is next, and that a lot of the builders won’t be people.
Models get better at writing code every few months. That doesn’t make a primitive less useful. It makes it more useful, because whatever is writing the tool now has somewhere solid to stand.
With yeet, you can:
Because the firewall, the dashboard and the sandbox you bought only do what their vendor thought of. yeet lets you build the one your infrastructure needs.
docker run turned namespaces into a primitive. yeet run does it for the kernel. Try it:
curl -fsSL https://yeet.cx | sh