ByteDefense runs an AI model directly inside your JVM build process to scan, detect, and auto-fix vulnerabilities — without sending a single line of code to the cloud.
A security engine that lives inside your build process. Not a dashboard you check after deployment.
Jlama loads a quantized coding model directly into your JVM build. No external API calls, no docker daemons. Pure in-memory inference under 1.5 GB RAM.
Goes beyond traditional AST scanners. ByteDefense understands semantic code logic to identify time-based backdoors, data exfiltration conditionals, and privilege escalation paths.
When a vulnerability is found, the engine generates a patch, compiles it locally to verify correctness, then creates a Git branch and opens a Pull Request automatically.
Every AI-generated fix is validated through the Java Compiler API before committing. If it doesn't compile, it doesn't ship. No broken builds from automated patches.
From commit to remediation in under 15 seconds on a standard runner.
ByteDefense triggers automatically from your GitHub Actions workflow. It reads the changed files and maps the AST tree.
Jlama loads the quantized Qwen 2.5 Coder model into the JVM heap. Your code is analyzed semantically for logic bombs, backdoors, and OWASP Top 10 vulnerabilities.
If a vulnerability is found, the engine generates a remediated version and compiles it in-memory with javax.tools.JavaCompiler to ensure correctness.
The engine branches your repo, commits the verified fix, and opens a Pull Request titled [ByteDefense Auto-Fix] with a complete diff and explanation.
Existing tools scan for known patterns. ByteDefense reasons about your code like a security engineer would.
The Jlama engine runs GGUF model weights directly inside your JVM heap. Your source code never leaves your runner, your network, or your jurisdiction.
Optimized for shared 2-core, 4 GB RAM GitHub Actions runners. The quantized Q4_K_M model loads in under 1.14 GB. No GPU required.
Traditional static analysis flags SQL injection patterns. ByteDefense understands semantic logic — it catches time-gated backdoors, environment-dependent exfiltration, and chained privilege escalation.
Every AI-generated code fix is validated through javax.tools.JavaCompiler before being committed. Broken patches never reach your main branch.
Built for enterprise compliance teams that can't send code to external clouds.
Virtual Threads allow ByteDefense to scan hundreds of class files concurrently without spawning heavyweight OS threads, maximizing throughput on limited runners.
The Jlama integration executes GGUF model weights natively inside the JVM through Java vector intrinsics. No Python runtime. No ONNX. Pure Java inference.
Quantized Q4_K_M weights keep inference strictly under 1.14 GB RAM. ByteDefense is designed for the cheapest shared CI/CD runners — no GPU required.
ByteDefense makes zero outbound HTTP requests during inference. Your proprietary source code and AST trees never leave your build container's network boundary.
“We integrated ByteDefense into our GitHub Actions pipeline in under 30 minutes. It caught a time-gated data exfiltration backdoor in a third-party dependency PR that our existing SAST tools completely missed.”
“The air-gapped model execution was the deciding factor. Our compliance team cannot allow source code to leave our VPC. ByteDefense runs entirely inside the runner — no exceptions.”
“The auto-PR feature saves us hours. When a vulnerability is flagged, the engine creates a branch, patches the code, verifies it compiles, and opens a clean PR. Our review backlog dropped 40%.”
Add ByteDefense to your GitHub Actions workflow in 5 minutes. Your first scan is free.