Patch CVEs in minutes
The yeet programmable firewall is host-based intrusion prevention with virtual patching. When a CVE reaches the exploited list, the yeet agent writes the rule, your team reviews it, and the Linux kernel enforces it on every host in milliseconds.
- CVEs are analyzed as they are published
- Agents write patches immediately and submit for review
- Policy is applied in milliseconds without redeploys

AI is turning every CVE into a serious vulnerability
Exploitations do not wait for a vendor cycle. AI makes it easy to take advantage of your vulnerabilities before the patch from your provider arrives.
CVEs published per year
Source: National Vulnerability Database
Go from advisory to live rule in minutes
The time between a CVE reaching the exploited list and a rule matching it on the wire becomes a pull request review, not a vendor cycle. yeet writes it into the kernel beside the rule that is running and flips traffic over in one step.
Scroll sideways for the whole diagram.
<200 ns
Header match, median
The in-kernel matching step, measured on a loopback capture
~100 ns
Decision per packet, mean
On real HTTP, p99 under 1 µs, measured in our lab
3 to 6 ms
Rule change to live
Compile to atomic flip, no restart, measured in our lab
0
Hops added
No proxy, no sidecar: the verdict is produced on the origin host
Beside your edge, on every host
The yeet programmable firewall runs behind your TLS termination, between the NIC and the kernel's network stack. It adds no hop, sees the east-west traffic your edge never sees, and leaves your WAF and NGFW exactly where they are.
Scroll sideways for the whole diagram.
Configure vs. Program
Configurable firewalls let you choose among the matches a vendor built, on their timeline. A programmable one lets you write the rule yourself and deploy it immediately.
Questions
Is this a WAF?
No. A WAF is a proxy or an edge service that terminates TLS and ships managed rulesets. The yeet programmable firewall adds no hop and terminates nothing: it runs on the host, behind your TLS termination, and reads the decoded request in the kernel. Keep your WAF. This covers the origin behind it.
Does it replace my next-generation firewall?
No. Your NGFW decides on the network path with the vendor's signatures. The yeet programmable firewall decides on the origin host with rules the yeet agent writes and your team reviews, so the time between a CVE and a matching rule is a review, not a vendor cycle. They run side by side.
Can it contain a host?
Yes. From the network in, a rule drops everything that reaches a host or a container except traffic from the sources you trust, live in the same 3 to 6 ms, so you can reach the box and fix it while everyone else is held off. Outbound containment, holding what the host sends, uses the kernel's egress hook, which the runtime attaches the same way. It is next on the roadmap; inbound is what ships today.
Does it work per container, or only per host?
Per host, per interface, per port, per container or per pod, from the same program. By default it attaches in the host's network namespace, where every container's traffic crosses an interface the host owns, so pod-to-pod traffic on the same node and anything arriving from outside are covered with no sidecar and no change to the pod spec. A rule reads the destination port, the protocol and the interface, so it can narrow itself to one service. For one container or one pod, the runtime attaches inside that container's network namespace or on its cgroup, and the agent resolves a container name or a pod label to the namespaces and cgroups on each node. Overlay networks are matched at the pod's interface, after decapsulation.
What about TLS?
XDP sees bytes as they come off the NIC. If those bytes are TLS records there is nothing to match, so the yeet programmable firewall runs where traffic is already cleartext: origin servers behind an edge, a load balancer or a sidecar that terminates TLS. The TLS client hello is the exception, since the server name travels in the clear.
Who writes the rules?
A specialized network security agent that is bound by yeet's ISA. It reads the CISA KEV feed, drafts a rule for each CVE that touches software you run, tests it against a reproduction of the exploit, and opens a pull request with the C, the assembly and the bytes. Your reviewer approves. Nobody on your team needs to know how to write a firewall rule, and our engineers work with you on the first rules and rollout.
What happens if a rule is wrong?
A program that cannot read a packet passes it, unless you chose fail-closed for that rule. Run a new rule in monitor mode first and watch the histogram, then switch it to enforce. Unapply clears the program and drains the flow table.
Can a rule crash the kernel?
No. The matcher is one XDP program, checked by the Linux verifier when it loads. Rules are data it interprets inside fixed budgets, so a rule cannot crash the kernel, loop forever or read past the packet.
What does it need from my environment?
Linux 6.12 or later on the origin hosts, cleartext traffic at the NIC (TLS terminated upstream), and the yeet runtime, installed via a package from your distribution's package manager, a container image, a Terraform provider or a one-line installer, as a Kubernetes DaemonSet or a systemd service. It runs on VMs or bare metal in any cloud that is in production on enterprise traffic, and updates ride your normal image rebuild.
How is this different from a signature my firewall vendor ships?
A vendor signature is written on the vendor's schedule, in the vendor's format, and lands at the edge. Here the rule is a program the yeet agent writes from the CVE's own indicators, reviewed in a pull request, then compiled on each origin host and matching at XDP seconds after the merge. The two are not exclusive. Keep the edge signature; the host rule covers the hours before it ships and the east-west traffic the edge never sees.