malware0 · analysis API for agents
Real-time malware analysis for AI agents
One API call, before your agent opens a file, installs a package, or acts on a fetched instruction. malware0 reverse-analyzes the sample on behavior, in real time — no signature database, no waiting for someone else to be the first victim. Built for agents to call directly.
curl -s https://api.malware0.com/v1/analyze \
-H "Authorization: Bearer mw0_your_key" \
-H "Content-Type: application/json" \
-d '{
"kind": "file",
"source": {
"url": "https://cdn.example.com/report.xlsm"
}
}'{
"id": "an_9f2c…",
// clean | suspicious | malicious
"verdict": "malicious",
"confidence": 0.97,
"family": "downloader/vba",
"reasoning": "Auto-open macro decodes a base64
blob, executes it via WScript.Shell; contacts
3 rare hosts.",
"iocs": { "hosts": ["a3f….top"], "sha256": "…" },
"latency_ms": 1840
}The core loop: a sample in, a verdict out — clean, suspicious, or malicious, with the reasoning that produced it.
Why signatures don't work anymore
Traditional antimalware is already too slow
Antivirus and threat intelligence share one structural weakness: they need a victim first. The defense is manufactured after an attack is observed and reported.
victim hit ─▶ reported ─▶ research team reverse-engineers
│
▼
signature written ─▶ pushed to devices ─▶ detectable
first victim: never protected — no signature existed yet
later victims: protected — but ONLY after the signature shipsThe old bargain
Accept that the first victims are unprotected in exchange for protecting everyone after the signature is written. It held for decades because writing the signature was faster than the malware could change.
Why it collapses
An attacker's AI generates fresh malicious code faster than the signature latency — a new variant per target, unrecognizable by the time a signature ships. The “later victims” the model existed to protect are now hit by code nobody catalogued. Everyone is a first victim.
The only defense that holds decides in real time, on behavior, with no signature in the loop. That is what malware0 is.
How it works
Analysis, not lookup
Small models reverse-analyzing adversarial malware — including code an LLM just wrote — in real time, before an agent acts on it.
Text is code
When an agent pulls text into a skill or its context — a fetched page, a tool result, a retrieved doc — it will act on it. malware0 judges that text as executable intent, not inert bytes, because that is how the agent treats it.
Binaries, reverse-analyzed
For real files and packages, malware0 reasons about what the sample does — at the moment of contact, not by matching a hash someone already catalogued. A sample it has never seen is judged on behavior.
Built for agents to call
No console to click through. An agent holds its own key and calls /v1/analyze itself, gets a verdict in ~1–2s, and decides whether to proceed — the same loop OpenGuardrails runs on every action.
What you can send
Four kinds of “is this safe to touch?”
file
A binary, document, or archive an agent is about to open — by URL or uploaded bytes.
package
A dependency it is about to install or import — npm, PyPI, Go, crates — vetted for malice, not CVEs.
url
A page or endpoint it is about to fetch — drive-by content, hostile scripts, redirects.
text
Instructions it pulled into context — judged as executable intent, not as text.
Where it fits
The analysis engine behind agent antimalware
malware0 is the real-time engine; OpenGuardrails is the runtime that calls it on every action. Use the API directly, or get it wired into a policy through OpenGuardrails.
API
Call it directly
Read the API →
Pricing
$20 / month
See pricing →
OpenGuardrails
AI Runtime Security ↗
Learn more →