Continuous testing for every tool your MCP server exposes.
Kerno discovers each tool your server exposes, tests its output and schema against the running server, and flags a change before the agents calling it break.
Every test comes from the schema your server declares and the tools it exposes.
Live protocol discovery
Kerno connects to your running server and lists what it exposes, including tools registered at runtime.
Every tool and resource covered
Each one becomes its own subject, with scenarios of its own and a baseline that tracks it between runs.
Schema-aware planning
Kerno reads the input and output schema your server declares, and checks returned data against it field by field.
Tool error assertions
Kerno checks that bad input comes back flagged as an error, with a message that says what went wrong.
Output and schema drift
A baseline records what each tool returns today, and the next run reports any field that moved or was renamed.
MCP-native test plans
Plans that slip into HTTP language get rejected and rewritten, so scenarios stay in the protocol they test.
Covers output, schemas, errors and drift for every tool and resource you expose.
Tool output
Returned content, structured data, and the fields each call produces.
Schema conformance
Declared input and output schemas, required fields, and value types.
Error handling
Invalid input, missing arguments, and failures surfaced as tool errors.
Input validation
Boundary values, wrong types, and arguments the schema does not allow.
Authorization
Permission and access checks, where your server enforces them on a call.
Output drift
Renamed fields, changed shapes, and values that move between runs.
- TypeScript
- JavaScript
- Python
- Java
- PostgreSQL
- MySQL
- MongoDB
- Redis
- Kafka
- AWS
Kerno applies your rules and standards to every tool it plans and tests.
Reads your rules and standards in plain English
Write a rule the way you would explain it to a new engineer, and Kerno applies it to every tool on your server.
Works from the context your team already wrote
Agent instruction files, service READMEs and the docs in your repository shape how every tool gets tested.
Gets more accurate with every run you review
Kerno learns from each run and the feedback you give it, and carries what it learns into every later tool test.
FAQs
Got any extra questions? Reach out on our community channel and we'll be happy to help.
How does Kerno test an MCP server?
Kerno connects to your running server, discovers each tool and resource it exposes, then runs scenarios that check output, schema conformance and error handling against that server.
Does Kerno discover MCP tools automatically?
Yes. Kerno connects to your running server and discovers every tool and resource as its own subject, including the ones your server registers at runtime.
What happens when a tool changes?
Kerno keeps a baseline of what each tool returns. On the next run a renamed field, a changed shape or a different value shows up as a diff against that baseline.
Which MCP servers can Kerno test?
Any server Kerno can reach over the MCP protocol, in any language, since discovery happens at the protocol level rather than in your source.
How do I point Kerno at my MCP server?
Give Kerno the URL your server listens on. It connects, lists what the server exposes, and each tool becomes a subject you can test on its own.
Does MCP testing run in CI?
Yes. Committed scenarios replay in CI on every change.