Kerno
FYCK Limited · Coding
Kerno is a runtime quality engine that writes and runs backend tests against your real stack, so coding agents catch regressions and security bugs before they merge.
About Kerno
What Is Kerno
Kerno is an AI backend testing tool built for teams that ship code with AI agents. It doubles as an API testing tool and a runtime testing tool. It learns how your product works, maps the user flows running through your app, and turns each one into automated tests. Those tests run against your live app and its real databases and queues, not against mocks.
The problem Kerno targets is the slow feedback loop in modern AI-assisted development, and it acts as backend QA for coding agents. Agents can write code fast, but proving that code works at runtime usually waits until CI, hours later. By then small mistakes have piled up, and fixing them costs real engineering time. Kerno moves that check inside the agent's session so a broken change gets caught while the agent is still working.
The main limit is scope. Kerno works one repository at a time, and it's driven through a coding agent that supports MCP (the Model Context Protocol, a standard way for AI tools to connect to other software). Teams that don't use an agent can still re-run committed tests through a CI action, but they lose the in-session loop.
Getting Started
- Install the CLI with
npm install -g @kerno/cli, then runkerno loginto authenticate in your browser. - Point Kerno at your repo with
kerno init. It indexes your code, maps every entry point, and registers itself as an MCP server for your agent. - Let your agent connect Kerno to your running app and confirm how to sign in, seed test data, and which services Kerno may touch.
- Ask your agent to generate baseline tests for your critical flows, then review the plan before they run.
- Make a code change and let Kerno re-run the affected flows. It shows the exact step that broke.
Product Information
A quick look at Kerno's pricing, supported platforms, and performance.
Best for
The users, tasks, and scenarios where this tool fits best.
Users
- Backend developers
- Small engineering teams
- Platform and QA leads
Tasks
- Verifying AI-written code
- Catching regressions early
- Security checks on backend flows
- Keeping tests current
Scenarios
- Migrations and large refactors
- Testing an MCP server
- Rolling out AI across a team
Key features
Tests against your real stack
Kerno runs scenarios against your actual running application, its databases, and its queues rather than against mocks. That means it catches the functional and security bugs that only appear at runtime. Supported datastores include PostgreSQL, MySQL, MongoDB, Redis, Kafka, RabbitMQ, and S3-compatible storage.
Deterministic blast radius mapping
Kerno indexes your code into a graph of functions, classes, and entry points, then follows the call graph to find exactly which entry points a change touches. It avoids the approximate matches you get from vector embeddings, so you know what really moved.
End-to-end flow testing
Beyond single endpoints, Kerno tests the user journeys that cross several entry points as one connected path. Each flow runs from the first request through to the outcome read back from your system, so integration gaps surface before release.
Security testing
The security layer validates token handling, role-based access rules, permission scopes, injection, excessive data exposure, mass assignment, and SSRF, mapped to the OWASP Top 10. You trigger it when you want it rather than on every run.
Custom rules in plain English
You can give Kerno your business rules in plain words and scope them to specific repositories and file paths. It applies those rules on every run, so a policy like never returning stale records is checked automatically.
Built for coding agents over MCP
Kerno runs inside your agent's loop and connects through MCP. Claude Code, Cursor, Windsurf, and Codex are the verified setups. The agent drives Kerno, reads results, and fixes what broke without leaving the session.
Pros and cons
Pros
- Runs inside the agent session, so broken changes surface in seconds instead of hours later in CI.
- Tests against real databases and queues, which catches runtime bugs that mocks hide.
- Generates and updates tests for you, so the manual test-maintenance work teams usually carry goes away.
- Learns your custom rules in plain English and applies them on every run.
- Covers security categories like authorization, injection, and SSRF when enabled.
Cons
- Needs a coding agent that supports MCP for the full in-session loop; teams without one fall back to a CI action.
- Works one repository at a time, so multi-repo products need separate setups.
- The free plan caps you at 30 test runs, 1 repository, and 1 user.
- Kerno detects routes across many languages, but scenarios themselves are written in TypeScript.
Frequently asked questions
Kerno is a runtime quality engine for backend code. It learns how your app works, maps your user flows, and runs tests against your real stack to validate each code change inside your coding agent's session.
Related content
Explore related tools, skills, and articles for Kerno.
Kerno Alternatives
Base Code
Base44 (Wix) · Coding · ProductivityBase Code is a shared cloud development environment from Base44. Teammates describe changes to an existing GitHub codebase in chat, preview them live and send them back as pull requests.
Google EmbeddingGemma 2
Google DeepMind · Writing · Image · CodingGoogle EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.
GitGlow
GitGlow · Coding · ProductivityGitGlow is a local-first desktop Git client that lets independent developers review their own code and their AI agents' changes in one place before shipping.