Kerno 1.0

Kerno is an AI backend runtime QA engineer that writes and runs backend tests against your running application and its real dependencies. It independently tests your critical flows locally against your real stack, catching runtime and security bugs inside the agent loop before they merge. Kerno is built for engineering teams and coding agents that ship backend code and need fast, trustworthy verification of every change, and its stated purpose is to verify and secure everything your agents ship — locally. In most backend teams, the bottleneck is not writing code, it is proving it works at runtime. Verification typically happens hours later in CI, where failures pile up, draining engineering time, forcing expensive rework and slowing releases. The content illustrates this with simulated DORA-style metrics where lead time, production incidents, change failure and weekly rework all rise as verification is delayed. Static review reads your code and unit tests run on mocks, so neither can see runtime behavior such as double charges across services, authorization leaks across tenants, SSRF through a callback URL hitting internal metadata, broken contracts, resilience failures and MCP tools that return an empty body instead of an error. Kerno is positioned as the runtime quality and security layer for your backend, giving every developer and agent staff-level testing knowledge to catch the expensive runtime issues DIY testing and code review miss, right at the source. Kerno organizes its work into three modules. Module A, Real evidence, verifies every code change against your live stack and dependencies, catching the functional and security bugs that only surface at runtime, before they ship. Module B, E2E coverage, verifies every critical flow a code change touches: Kerno maps a change's blast radius and verifies each flow end to end. Module C, Consistent quality, brings the same high-quality verification loop to every engineer by giving coding agents structured signals and persistent code context on every change. The runtime test floor follows four steps. Step 01, Map: Kerno builds a graph of your codebase and docs, maps every entry point and the dependencies behind it, and maps your critical user flows with you. Step 02, Test: it tests each user flow as one journey across your APIs, then covers every entry point behind it in depth. Step 03, Verify: it re-runs every flow a change touches and shows the step that broke, with the outcome the user expected and what actually happened. Step 04, Heal: it updates entry-point tests as your product changes and re-generates flows when behavior changes on purpose, so the suite evolves with your code. In practice this means a diff on a flow such as checkout step 03 on POST /payments is surfaced as a specific change — for example charges going from 1 to 2 — and self-healing records intended changes such as updated tests and added flows from a pull request. Kerno catches the bugs that only appear at runtime inside the agent loop, across a set of verification gates. End-to-end user flows verify complete user journeys across your APIs, from the first request to the outcome read back from your system. Contract and schema validation checks request and response structures, data types, required fields, serialization rules and version compatibility. Authorization and authentication reviews token validation, role-based access rules, permission scopes, session handling and credential-related flows. Security validation covers broken object- and function-level authorization, injection, excessive data exposure, mass assignment and SSRF against the OWASP Top 10. Boundary and edge cases validate payload size limits, pagination behavior, null or empty values, malformed inputs and constraint-based validation. Error handling and resilience validate status codes, error body formats, retry behavior, backoff procedures, timeout handling and controlled fallbacks. MCP server testing verifies each tool an MCP server exposes, including returned content, structured output, schema conformance and error handling. AI agent testing, listed as coming soon, is intended to verify how your agent calls tools, chains model steps and handles streaming responses, with model providers mocked for deterministic runs. Kerno connects to the services and datastores you already run and manages the data layer so it can exercise them the way your application does. Kerno runs locally: `kerno init` starts the agent, indexes your endpoints, and runs a Kerno MCP server that your coding agents connect to, while `kerno status` reports indexing and application reachability. Kerno learns your business and standards: you can define custom rules in plain English, scoped to the repos and paths you choose, and it applies them on every run in scope. It also learns from every test run and the feedback you give it, building a sharper model of your codebase and standards over time through a lessons store that records discovered behaviors. Setup follows a clear schedule. In the first hour you install Kerno, point it at your repo, map every entry point, connect it to your running app and its dependencies, and map your critical user flows together. By the first day, Kerno covers your critical flows and builds baseline tests for every API, task and event behind them, and adding Kerno instructions to your agent guidance file enables validation of every change. Within the first week you roll out to your team, with the Kerno MCP connected to your agents, validating every code change and re-running the flows it touches before they reach production. A runtime control console at portal.kerno.io provides Analytics, Coverage and Behaviour Drift views across all repositories, showing flows covered, entry points covered, code changes tested, potential issues caught, tests in your suite and active developers, plus per-repo breakdowns. The stated benefits are concrete. The content reports 6× faster merges for PRs tested by Kerno, 48% more runtime issues caught, and 10 hours freed up per engineer every week to build. Verified customers describe Kerno as being up and running in minutes with no manual work, making API migrations smoother by instantly validating that every change made by Cursor worked as expected, providing quick feedback with no manual effort when used with Claude Code while saving debugging of integration issues post-merge, catching side effects and issues that would definitely break backends, and acting as a force multiplier that lets teams ship releases much faster without the manual overhead of QA. Kerno fits into everyday delivery workflows for backend teams. A team maps and tests its critical flows, such as checkout, refund-an-order and team-invite, then uses the console to track coverage, analytics and behavior drift across repositories. When an agent adds a feature, for example partial refunds to checkout, Kerno validates the affected flows and endpoints and reports failing steps such as a double charge on POST /payments before a fix brings all checks back to passing. Bugs are caught inside the agent's session before a PR is opened, and every PR is then re-checked in CI. Engineers can review reported potential issues such as a PATCH with no changed fields returning 200 and bumping updated_at, an IDOR attempt blocked when a customer changes another customer's id, mass assignment protection, payment details never appearing in a response, and an email change that stays inactive until confirmed. It also supports testing of MCP tools such as get_order_status and consumer entries such as charge.retry and order.shipped. Kerno is aimed at engineering teams, individual engineers and coding agents shipping backend code. It connects over MCP to any coding agent, including Claude Code, Codex, Cursor and GitHub Copilot. It supports eleven languages (TypeScript, JavaScript, Python, Java, Go, Rust, C#, C, Kotlin, Ruby and PHP), eight data and messaging systems (PostgreSQL, MySQL, MariaDB, MongoDB, ClickHouse, Redis, Kafka and RabbitMQ) and three clouds (AWS, Azure and Google Cloud). Security is a stated priority: Kerno encrypts everything end to end, never retains your code, and a SOC 2 Type 2 audit is in progress, with private code never stored or used for training. A free starting path is offered through `kerno init` and a free signup at portal.kerno.io, and the content references free-plan organizations retaining event data for 30 days versus 90 days for paid plans, indicating both free and paid tiers. Kerno's core promise is simple: verify and secure everything your agents ship, locally. By moving runtime verification into the agent loop instead of waiting for late-stage CI, Kerno gives every developer and agent staff-level testing knowledge, catches expensive functional and security issues at the source, and helps teams merge faster with fewer regressions reaching production.