From the first threat
to the verified patch.
codesafe works around the clock, end to end: it detects the attacks on your site and the errors in your code, shields against the attack pattern while the fix ships, and proves the fix held. Built for a time when AI writes the exploits.
Most tools stop at the alert. codesafe keeps going:
- IDENTIFYEvery error, attack probe, failed login, stalled cron job and silent page becomes one case, with its evidence and severity attached.
- SHIELDWhile the fix is on its way, a Shield rule guards the door on your sites within minutes, before your code runs.
- PATCHIt reads your repository, writes the fix and opens the pull request; what gets merged stays your decision.
- VERIFYAfter the release it re-runs the request that failed, so you know the fix actually held.
- LEARNEvery verdict, yours and the AI's, sharpens its rules, so the next attack is caught sooner.
If a site is your responsibility, this is for you.
Operated from Vienna, in the EU or on your own servers personal data masked on arrival your instance, not shared tenancy
AI writes the exploit. AI has to write the patch.
Finding a hole now takes minutes of machine work, and the machines are busy on both sides: attackers use AI to weaponise a fresh vulnerability first, while defenders still read advisories by hand. A defence that takes weeks has already lost, and one you have to prompt is not running when it matters. The only defence that keeps up runs at machine speed, around the clock, on your own traffic - that is codesafe.
Anyone who looks after a website.
However many sites you run, one codesafe watches them all, and the bill does not grow with the client list.
Agencies and freelancers
Every client site sits in one codesafe under its own key, and one inbox tells you which of them needs you today.
In-house teams
Every app you run sits in one place, whatever it is built in, so shipping and watching happen in the same view.
WordPress and CMS sites
Install the plugin and paste a key, and errors, probes and plugin CVEs land in one list.
Teams whose data cannot leave
Your own instance runs on infrastructure you control. Personal data is masked on arrival, and the original stays encrypted until someone reveals it for a reason that is logged.
High-traffic portals
An error storm hits Redis, not your app, and codesafe indexes it behind you.
Whoever is on call
codesafe ranks, patches and verifies first, and pages you only when a person is needed.
Every error, closed end to end.
Every error monitor identifies and classifies, and the newer ones advise and patch. Almost none verifies the fix or learns from its mistakes. Step 04 runs two ways at once: while the patch is on its way, the Shield guards the door.
-
01 IDENTIFY
Every error, probe and refused login becomes one case, with its evidence attached.
-
02 CLASSIFY
Severity is decided on arrival, so nobody has to triage a list by hand.
-
03 ADVISE
It explains the root cause in plain language and, where it is safe, proposes a patch.
-
04 PATCH
It writes the fix and opens the pull request, but it never merges: what goes in stays your decision.
04 SHIELD
A virtual patch drawn from the attacker's own requests reaches your sites in minutes. It watches first, and blocks once the evidence says it is safe.
-
05 VERIFY
It waits for the release, then re-runs the request that failed; once the fix holds, the Shield's rule is lifted.
-
06 LEARN
People and the AI judge every rule: one that raises false alarms is narrowed or retired, one that let an attack slip is widened. Each change is a proposal, reviewed by ovos and shipped in the next release.
Attackers use AI now. So does your defence.
Every attack is a free penetration test, if someone reads it - and reading them is exactly what codesafe does.
Your site is probed every day - every probe maps where it is weak.
One attack in eight is an exploit attempt, not a probe.
codesafe keeps that traffic out of your bug list - and reads it.
It names the address, the weak spot and the patch.
Then it re-runs the request, to prove the door is shut.
Measured by our own codesafe, 30 September – 29 October 2026: 93 968 reported rows, 9 582 of them code errors; 5 129 rows with an attack shape, from 254 addresses in 354 waves, 629 of them exploit attempts.
While the patch waits for its release, the rule is already live.
Every site pulls its rules from codesafe and judges each request before your code runs. codesafe writes the rules itself, from two sources: a published vulnerability in software you run, and an attack that broke your own code. A rule blocks on its own only when codesafe can show what it stops and whom it spares; every other rule watches first.
- kind
- virtual patch
- where
- admin-ajax.php · action
export_orders - who
- callers without
manage_options - from
- the CVE's fix · report plugin 2.4
- drafts
- 2 of 2 agree · the trial passed
- sites
- demo-shop, demo-web
- mode
- block · at once
- answer
- 403 - before the plugin runs
- kind
- virtual patch
- where
- /shop/product · query
id - test
idis not a number- from
- an SQL error three attacks threw in your code
- mode
- observe · then by its evidence
- until
- the fix is verified
-
01 DRAFT
From the vulnerability's fix, or from the requests that broke your code: codesafe finds the entry point and the parameter, and drafts the rule twice. Each draft must stop the attack and spare every honest request on record.
-
02 GATE
When a vulnerability's two drafts agree on the request and guard it the way the vendor's fix does, the rule blocks at once, and an exploit attempt gets a 403.
-
03 OBSERVE
Every other rule goes live blocking nothing and counts what it would have stopped, and whom.
-
04 PROMOTE
Once every site has held it long enough, nothing it matched was signed in and every match came from an attacker, it blocks. Nobody has to approve it.
-
05 ALARM
A block that turns your real visitors away goes back to observe by itself, and is drafted again against the requests it refused. What an attacker could fake raises an urgent case for a person instead.
-
06 RETIRE
A rule lives as long as its evidence: the vulnerable version still installed, the issue still open. A week after the fix is in, it is lifted; if the hole comes back, so does the rule.
It runs on any stack, with one rule language for all of them: dedicated plugins exist for WordPress - where it works even before WordPress loads - and Node.js, more to follow on request. In codesafe, one switch per project - block, observe or off - and one per rule; on the server, its own off switch.
It learns from what it got wrong.
Every night it checks its own rules both ways: what they caught that people or the AI judged wrong, and what slipped past them. A rule that catches the wrong thing is narrowed or retired; what got through becomes a new or wider signature. Each change is tested first, then waits in SETUP → IMPROVEMENTS and goes as a pull request to codesafe's own repository, where ovos reviews it. Every instance gets what ovos merges with the next release.
Who judges the rules
You dismiss what a rule raised, mute an issue it marked, or soften the rule. Each one is a verdict against it.
Every night the AI reads the traffic no signature decided on. An attack a signature should have caught is a verdict against that signature.
When an issue is analysed, the AI reads its request too. A signature that fired on no attack, or a check that ranked the issue too high, gets a verdict against it.
Your word weighs more: two of your verdicts open a draft, where the AI needs three of one kind. And the AI never changes a rule a person wrote.
- evidence
- 41 requests no signature caught, on 3 sites
- judged
- by the AI screen, over 3 nights
- change
- one signature, widened · 4 lines
- trial
- catches all 41 · flags none of the benign corpus
- checks
- CI passed
- state
- waiting for review
-
01 JUDGE
Every verdict, yours or the AI's, is kept against the rule it names, with the request behind it.
-
02 DRAFT
Enough verdicts, and it writes the change: a signature tightened or widened, a rule narrowed, a threshold moved, a signature retired - or a rule from an advisory.
-
03 TRIAL
The draft runs against everything seen so far - what it would catch, what it would wrongly flag.
-
04 PROPOSE
It lands in SETUP → IMPROVEMENTS with its evidence and its trial, and as a pull request against codesafe's own repository, the CI read back.
-
05 DECIDE
ovos, who builds codesafe, reviews it and merges it, and the next release brings it to every instance. Only a change built on a false report is declined - and it is never proposed again.
An advisory does not wait for a release: its drafted rule goes straight into the Shield of the instance that saw it, with no pull request and nobody to approve it. Every site pulls it within five minutes, blocking at once where the gate allows and observing otherwise.
Eight jobs it never hands back to you.
Each one is a task you would otherwise do by hand, whenever it arrives: at 2 a.m., on a Sunday, mid-meeting - usually after your users have already noticed.
Nothing is lost in a storm.
Errors land in Redis in under a millisecond, and your app serves on while codesafe catches up.
A thousand errors, one line.
The same fault collapses into one row with a count.
It decides what is serious.
Impact and urgency are scored on arrival, per project.
It writes the patch.
It reads your repository, writes the diff and opens a pull request for you to review.
It proves the fix held.
After the release it re-runs the request that failed - measured, not claimed.
It watches what goes quiet.
When a cron job stops or a page goes down, you hear it before your users do.
Your AI can ask it.
Point Claude at codesafe over MCP with one command, and it reads and acts on everything you see in the screens.
Every stack you run.
A drop-in library, a snippet or a CMS plugin. Your CMS not covered? Tell us - we write the client and integrate it for you.
See it working - no login, nothing to install.
This is a running codesafe instance, not a tour of one: errors, uptime checks and attack waves keep arriving while you read, and you can work on them as they land.
- It keeps happening. A seeder feeds the instance around the clock, so the grids are never empty and never yesterday's.
- Triage is yours. Filter, search, star, check, resolve, mute, acknowledge an attack wave. All of it reversible - whatever you leave behind heals on the next tick.
- Nothing leaves the box. The writes that would reach the outside world - mail, tickets, project keys, the agent endpoint - are shut, and it is seeded data, not anyone's.
- No sign-up. No account and no card: you are in the moment the page loads.
Then try it on your own site. Point one of your sites at a codesafe instance for a week - we set it up with you in a few hours, and you watch the first cases arrive. Ask for a pilot
The screens below come from a running instance - its security side first. Nothing is mocked.
…and on your phone
The same codesafe. Grids fold into cards, controls fit a thumb.
Before you ask.
- Will it block my real visitors?
- It is built not to. A new rule only watches at first: it blocks nothing and counts what it would have stopped, and whom. It starts blocking only once the record shows every match came from an attacker and none from a signed-in user - or, for a published vulnerability, when it refuses only what the vendor's own fix would refuse. If a blocking rule ever turns a real visitor away, it goes back to watching by itself. And any project, or any single rule, can be set to watch only.
- What if the AI writes a bad patch?
- There are two kinds, and neither gets in unchecked. A code fix arrives as a pull request: it never merges itself, and what goes in stays your decision. A virtual patch - a Shield rule in front of your code - is drafted twice, and each draft must stop the attack and spare every honest request on record; it blocks only on evidence, steps back by itself if it turns a real visitor away, never touches your code, and is lifted once the real fix holds.
- Does it slow my site down?
- No. A report leaves after your page has gone out wherever the runtime allows, gives up after a second at most, and never throws into your code. The Shield judges each request on your own server against rules it pulled ahead of time, so no visitor waits on codesafe - and if codesafe cannot be reached, your site keeps its rules and serves on.
- Where does my data go?
- Nowhere you did not choose: to your own instance, run by us from Vienna in the EU or by you on your own infrastructure. Personal data is masked on arrival and revealed only for a reason that is logged.
- Does it run on my stack?
- Errors come from PHP, Node, the browser, WordPress and any OpenTelemetry service. The Shield runs on any stack: dedicated plugins exist for WordPress (it works even before WordPress loads) and Node.js, more to follow on request. Missing your CMS? We write the client and integrate it for you.
Your own instance - not shared tenancy.
The only question is who runs the machine. One instance, one price - however many sites you point at it.
We run it for you
We operate your instance from Vienna, in the EU. You point your apps at it, and that is all there is to do on your side. Personal data is masked on arrival and stays encrypted until there is a logged reason to reveal it.
Get an instanceYou run it yourself
Your instance, on your infrastructure, inside your building - we set it up and hand you the keys.
Talk to usRunning a CMS we have no client for - TYPO3, Drupal, Shopware, something in-house? We write it and integrate it. Tell us the platform and the version.
Put codesafe on watch.
Start with the open demo - no login, nothing to install. When you want it on your own sites, we run your instance from Vienna, or you run it on your own infrastructure.