BPF-Guardian: Verified In-Kernel eBPF/XDP Generation & Multi-Turn RLVR

Empirical Evaluations

Generational Performance Progression

Evaluated directly on Hostinger Linux VPS (`6.8.0-106-generic`) with live `BPF_PROG_TEST_RUN` execution.

Primary Suite Benchmark Comparison: Base vs Prior Baseline vs SFT vs RL

Comprehensive 4-Panel Suite Breakdown

Synthesis, Standalone Repair, Confirmation & Combined suites

4 Panels • Full Breakdown

Key takeaway: On Protected Synthesis, base untuned Nemotron scores 0.0%, Qwen SFT v2 achieves 25.8%, Nemotron SFT v1 reaches 45.0%, and Multi-turn RL peaks at 49.2% Solve@2 (+35 net solved tasks on combined benchmarks).

Domain Robustness & Complexity Scaling

Packet Filtering, Routing, Telemetry & Transformations across algorithmic difficulty levels

Domain & Level Analysis

Key takeaway: Performance scales robustly across all 4 networking domains (PFS, NRF, PIT, PTR) and complexity levels (Level 1 Ingress 87.5%, Level 2 Stateful Maps 66.7%, Level 3 Advanced Consistent Hashing 47.9%).

Full Live VPS Kernel 6.8 Empirical Scorecard

Statistically paired McNemar significance comparisons against prior baseline

T = 0.0 Deterministic

Evaluation Benchmark	Suite Size	Base Nemotron 30B	Prior Baseline (Qwen3-8B)	Nemotron SFT v1	Nemotron RL N3 (Ours)	Relative Gain
Protected Private Synthesis	120 tasks	0 / 120 (0.0%)	31 / 120 (25.8%)	54 / 120 (45.0%)	59 / 120 (49.2%)	+90.3%
Protected Standalone Repair	120 tasks	79 / 120 (65.8%)	85 / 120 (70.8%)	91 / 120 (75.8%)	91 / 120 (75.8%)	+7.1%
Confirmation Benchmark Suite	60 tasks	20 / 60 (33.3%)	33 / 60 (55.0%)	42 / 60 (70.0%)	44 / 60 (73.3%)	+33.3%
N3 Stratified Dev Suite	48 tasks	—	18 / 48 (37.5%)	24 / 48 (50.0%)	23 / 48 (47.9%)	+27.7%
Total Combined Evaluation Suite	276 tasks	79 / 276 (28.6%)	137 / 276 (49.6%)	168 / 276 (60.9%)	172 / 276 (62.3%)	+25.6%

End-to-End System Pipeline

Multi-Turn RLVR & In-Kernel Reward Loop

How BPF-Guardian guarantees zero hallucinated kernel programs through live OS execution.

Phase N0 & N1 Step 01

Renderer & Baseline

`nemotron3_ultra_disable_thinking` strips internal reasoning tokens. 396 tasks evaluated zero-shot at T=0.0 & T=1.0 to establish strict empirical lower bounds.

• Context window: 4,096 tokens
• Zero template leakage

Phase N2 Step 02

Curriculum SFT Sweep

Hyperparameter grid search across LoRA ranks (r=16, 32) and learning rates (1e-4, 4e-4) on Tinker. Run B promotes with 75.8% standalone repair rate.

• Rank 32, Alpha 64
• 1,600 verified SFT tasks

Phase N3 Step 03

Interactive Multi-Turn RL

Two-turn RLVR loop with live VPS kernel feedback. Hardened tail-truncation prevents verifier disassembly overflow (>2.8 MB logs).

• Reward = 1.0 (Turn 1) / 0.9 (Turn 2)
• 30 steps Importance Sampling

Delivery Step 04

Hugging Face Hub PEFT

Export from Tinker sampler checkpoint to standard Hugging Face PEFT LoRA safetensors (1.47 GB), uploaded to main and rl-n3 branches.

• Hugging Face namespace: rvindra
• Datasets & Models certified

⚙️ The 4-Stage Live Kernel 6.8 Verification Pipeline

Every single training rollout and evaluation step executes this exact sequence on the Hostinger VPS with zero mocking:

1. Structure & Lint

Extracts pure C source, verifies single-section headers (`SEC("xdp")`), strips markdown fences, and blocks dangerous kernel helpers.

2. Clang BPF Compilation

Compiles with `clang-18 -target bpf -O2 -g -Wall -Werror`. Diagnostic errors capture precise line, column, and clang warning flags.

3. bpftool Kernel Load

Invokes `bpftool prog load` against the Linux 6.8 In-Kernel Verifier. Tail-truncation preserves the exact register bounds and pointer safety violations.

4. BPF_PROG_TEST_RUN

Direct kernel socket injection of binary hex packets. Verifies both return action (`XDP_PASS`, `XDP_DROP`, `XDP_TX`) and exact packet payload mutations.

Corpus Architecture

Curated SFT & RLVR Benchmark Datasets

Strict benchmark isolation, family-heldout cross-validation, and complete test fixture schemas.

Dataset 01 • Hugging Face

rvindra/bpf-guardian-sft

View on HF ↗

The combined instruction-tuning corpus merging v1 and v2 synthesis and repair datasets. Strictly audited with 0% overlap against the 36-task calibration benchmark.

Total Examples

2,320

Train Split

1,913

Val Split

407

Functional Network Domains

Packet Filtering (pfs) Routing & ECMP (nrf) Telemetry (pit) Transforms (ptr)

Dataset 02 • Hugging Face

rvindra/bpf-guardian-rl

View on HF ↗

The certified 264-task RLVR benchmark. Contains complete JSON packet test fixtures with input raw hexadecimal packets, expected XDP verdicts, and modified output buffers.

Train

144

Dev

Confirm

Canary

Integrity & Auditing

Accompanied by `contamination_audit.json` certifying 0% task leakage

PEFT Artifacts & Inference

Model Zoo & Usage Guide

Published on Hugging Face as standard LoRA adapters for transformers and PEFT.

Branch: main Nemotron SFT v1

nemotron-3.5-lightning-bpf-guardian

Optimized for single-turn synthesis and repair. Achieves 75.8% Standalone Repair rate and 168/276 on the combined protected benchmark suite.

revision="main" • 1.47 GB Safetensors

Branch: rl-n3 Nemotron RL N3

Multi-Turn Repair RLVR

Trained with two-turn live in-kernel reward loop. Achieves 49.2% Solve@2 on Protected Synthesis (+90.3% over prior baseline) and 73.3% on Confirmation.

revision="rl-n3" • 1.47 GB Safetensors

Base Architecture NVIDIA

Nemotron-3.5-Lightning

30 Billion Total Parameters with 3.5B active parameters per token Mixture-of-Experts (MoE). BF16 precision with high code synthesis capability.

nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16

Python: Load & Generate Verified eBPF with PEFT

PyTorch / Transformers / PEFT

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

base_id = "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16"
peft_id = "rvindra/nemotron-3.5-lightning-bpf-guardian"

tokenizer = AutoTokenizer.from_pretrained(base_id)
base_model = AutoModelForCausalLM.from_pretrained(
    base_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
# Load SFT model (revision="main") or RL model (revision="rl-n3")
model = PeftModel.from_pretrained(base_model, peft_id, revision="rl-n3")

prompt = """You are an expert Linux kernel eBPF developer. Write a complete, self-contained XDP C program that inspects incoming IPv4 TCP packets, extracts the destination port, and drops packets targeting port 8080. Output ONLY raw C source code."""
messages = [{"role": "user", "content": prompt}]

inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True).to("cuda")
outputs = model.generate(inputs, max_new_tokens=2048, do_sample=False)
print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))

Live Kernel Inspection

Level 3 Task: Maglev Consistent Hashing

Generated by Nemotron BPF-Guardian, loaded via `bpftool`, and verified with raw IPv4/TCP packets.

xdp_maglev_hash.c (Nemotron Generated) SEC("xdp")

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __type(key, __u32);
    __type(value, __u32);
    __uint(max_entries, 65537);
} maglev_lookup_table SEC(".maps");

SEC("xdp")
int xdp_maglev_router(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != __builtin_bswap16(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *iph = (void *)(eth + 1);
    if ((void *)(iph + 1) > data_end)
        return XDP_PASS;

    if (iph->protocol != IPPROTO_TCP)
        return XDP_PASS;

    struct tcphdr *tcp = (void *)(iph + 1);
    if ((void *)(tcp + 1) > data_end)
        return XDP_PASS;

    __u32 hash = iph->saddr ^ iph->daddr ^ ((__u32)tcp->source << 16 | tcp->dest);
    __u32 lookup_idx = hash % 65537;

    __u32 *backend_id = bpf_map_lookup_elem(&maglev_lookup_table, &lookup_idx);
    if (!backend_id)
        return XDP_DROP;

    /* Packet successfully routed to consistent backend */
    return XDP_PASS;
}

char _license[] SEC("license") = "GPL";

Linux Kernel 6.8 Verifier & Test Run Log VERIFIED PASS

# 1. Compiling with clang-18 BPF target
$ clang-18 -target bpf -O2 -g -Wall -Werror -c xdp_maglev_hash.c -o xdp_maglev_hash.o
[OK] Compilation succeeded without warnings (0.14s)

# 2. Loading program into live Linux 6.8.0-106-generic kernel
$ bpftool prog load xdp_maglev_hash.o /sys/fs/bpf/xdp_maglev type xdp
0: R1=ctx() R10=fp0
0: (bf) r6 = r1                       ; R6=ctx()
1: (61) r2 = *(u32 *)(r6 +0)          ; R2_w=pkt(off=0,r=0)
2: (61) r1 = *(u32 *)(r6 +4)          ; R1_w=pkt_end()
3: (bf) r3 = r2
4: (07) r3 += 14                      ; R3_w=pkt(off=14,r=0)
5: (2d) if r3 > r1 goto pc+48
...
42: (85) call bpf_map_lookup_elem#1
R0=map_value_or_null(id=1,off=0,r=4)
43: (15) if r0 == 0x0 goto pc+2
44: (b7) r0 = 2                       ; XDP_PASS
45: (95) exit
processed 46 insns (limit 1000000) max_states_per_insn 0 total_states 4

# 3. Dynamic Packet Testing (BPF_PROG_TEST_RUN)
Running fixture 01: IPv4 TCP syn to port 8080...
[PASS] Expected action: XDP_PASS (2), Got: XDP_PASS (2)
Running fixture 02: IPv4 UDP packet (non-TCP)...
[PASS] Expected action: XDP_PASS (2), Got: XDP_PASS (2)
Running fixture 03: Maglev hash lookup collision probe...
[PASS] Expected action: XDP_PASS (2), Got: XDP_PASS (2)

ALL 3 IN-KERNEL FIXTURES PASSED (Episode Outcome: REWARD 1.0)

Acknowledgements

Compute: Fine-tuned and evaluated via Thinking Machines.

BibTeX Citation

@misc{nemotron_bpf_guardian_2026,
  author = {Tarunokusumo, Ravindra},
  title = {Nemotron-3.5-Lightning BPF-Guardian: Verified In-Kernel eBPF/XDP Generation},
  year = {2026},
  publisher = {Hugging Face},
  howpublished = {\url{https://huggingface.co/rvindra/nemotron-3.5-lightning-bpf-guardian}}
}