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:

  1. IDENTIFYEvery error, attack probe, failed login, stalled cron job and silent page becomes one case, with its evidence and severity attached.
  2. SHIELDWhile the fix is on its way, a Shield rule guards the door on your sites within minutes, before your code runs.
  3. PATCHIt reads your repository, writes the fix and opens the pull request; what gets merged stays your decision.
  4. VERIFYAfter the release it re-runs the request that failed, so you know the fix actually held.
  5. 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

OPS, codesafe's landing view: the attacks in progress, the AI's latest checks, the open vulnerabilities, the fleet and Shield lines with what each site blocked, and the INBOX of cases ranked by attention
THE SHIFT

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.

Exploit, written by AI
minutes
Patch, the old way
weeks
Patch, with codesafe
minutes
WHO IT'S FOR

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.

THE FULL CIRCLE

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.

IDENTIFY01 CLASSIFY02 ADVISE03 PATCH04 SHIELD04 VERIFY05 LEARN06 THE LOOP closes itself
  1. 01 IDENTIFY

    Every error, probe and refused login becomes one case, with its evidence attached.

  2. 02 CLASSIFY

    Severity is decided on arrival, so nobody has to triage a list by hand.

  3. 03 ADVISE

    It explains the root cause in plain language and, where it is safe, proposes a patch.

  4. 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.

  5. 05 VERIFY

    It waits for the release, then re-runs the request that failed; once the fix holds, the Shield's rule is lifted.

  6. 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.

ATTACK TRAFFIC

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.

254addresses attacked our sites in a month
12%of their attacks tried an exploit, not a probe
354attack waves: one address, one site, one day

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.

SHIELD

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.

SHIELD · rule 17 example
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
set to block by the gate - nobody had to approve it
SHIELD · rule 23 example
kind
virtual patch
where
/shop/product · query id
test
id is not a number
from
an SQL error three attacks threw in your code
mode
observe · then by its evidence
until
the fix is verified
drafted from the requests that broke your code - lifted once the fix holds
  1. 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.

  2. 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.

  3. 03 OBSERVE

    Every other rule goes live blocking nothing and counts what it would have stopped, and whom.

  4. 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.

  5. 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.

  6. 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.

SELF-IMPROVEMENT

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
2 verdicts open a draft

You dismiss what a rule raised, mute an issue it marked, or soften the rule. Each one is a verdict against it.

AI screen
3 verdicts open a draft

Every night the AI reads the traffic no signature decided on. An attack a signature should have caught is a verdict against that signature.

AI analysis
3 verdicts open a draft

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.

PROPOSAL · learn/sqli-union example
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
VIEW PRDECLINE
  1. 01 JUDGE

    Every verdict, yours or the AI's, is kept against the rule it names, with the request behind it.

  2. 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.

  3. 03 TRIAL

    The draft runs against everything seen so far - what it would catch, what it would wrongly flag.

  4. 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.

  5. 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.

WHAT IT DOES

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.

IN USE

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.

Live demo
codesafe-demo.ovos.at
  • 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.

FAQ

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.
GET IT

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 instance

You run it yourself

Your instance, on your infrastructure, inside your building - we set it up and hand you the keys.

Talk to us

Running 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.