Research · Approach

Our approach to agent verification

A low sun half below a calm sea horizon

Kasper Muutra and Kristjan Hertsmann · November 2026

Agents now act for people

AI agents have moved from answering questions to taking actions. They read a company’s data, create records, send messages and call other agents, often without a person reviewing each step. Two open protocols make this easier: the Agent2Agent protocol lets agents discover and delegate to one another, and the Model Context Protocol lets an agent call tools on a server.

Both protocols ask the builder to describe what an agent or server does. An A2A agent publishes an Agent Card listing its skills. An MCP server lists its tools, with hints saying whether each one only reads, whether it can destroy data, and whether it reaches outside the system. Those descriptions are what other agents, app directories and security teams rely on when they decide what to connect. Very few of them are ever checked.

Suncly exists to check them. This page sets out how we think about that work: what we test, how we judge, and what we believe testing can and cannot tell you.

An agent is a set of promises

The fairest way to judge an agent is against what it says about itself. A generic benchmark tells you how an agent compares with others on tasks someone else chose. It doesn’t tell you whether this agent does what its own card or tool list claims, which is the question a person approving it actually has to answer.

So we treat every declaration as a promise. A skill on a card promises that a request of a certain kind will be completed in a certain way. A read-only hint promises that calling the tool changes nothing. A destructive hint is a warning the agent has chosen to give. Our tests are built from those promises, one case at a time, and every case is repeated, because an agent that keeps a promise once and breaks it the next time has not kept it.

How agents act, and where they slip

Every agent, whatever it is built on, loops through the same four moves. It reads its instructions and context. It decides which tool to use and with what arguments. It acts, which is where the world changes. And it reports what it did. Each move has its own way of going wrong.

Reading

An agent slips when it trusts text it shouldn’t. Instructions planted in a file, a web page or a tool’s output can be read as if they came from the person in charge. This is the root of prompt injection, and no amount of good behaviour elsewhere makes up for it.

Deciding

An agent slips when it guesses instead of checking, or reaches for a tool that has nothing to do with its task. Many of the incidents we follow began with an agent finding a credential or an API it was never meant to use, and using it because it could.

Acting

Most harm happens here. A destructive call with no confirmation and no limit on its scope can undo months of work in seconds. Whether an agent asks before it deletes, and whether it can only delete what it created, matter more than almost anything else it does.

Reporting

An agent slips when its account of what it did doesn’t match what it did, or when the same request produces a different story each time. People tend to trust an agent’s summary of its own work; that trust has to be earned by evidence outside the conversation.

Whose failure is it?

When a test fails, the obvious conclusion is that the agent is broken. Often it isn’t. In one recent test of an MCP server, all eight cases that didn’t pass traced either to the test account, which lacked a connection the tools needed, or to our own safety rules stopping a step we couldn’t prove was safe. None was a defect in the server.

Reporting those as failures would have been wrong, and it would have taught the owner to ignore our results. So every case that doesn’t pass carries an owner: the agent, the environment it ran in, or the test itself. We keep red for a confirmed mismatch between what was declared and what was observed. Everything else is reported as what it is.

Gaps belong in the report

An evaluation that hides what it didn’t test is worse than no evaluation, because it invites trust it hasn’t earned. A tool that was never called, a skill with no example to test against, a run our judge couldn’t decide: each of these is listed by name. An inconclusive result is never counted as a pass, and a test that was never run earns nothing in our score.

Every result is signed, along with the exact requests and responses behind it, so anyone holding the report can check it and re-run it against a later version.

How testing makes agents better

We don’t think of testing as grading. Done well, it gives builders three things they can act on.

The first is tighter declarations. When a test shows exactly what a tool does, its hints can say so precisely, and the agents that call it can rely on them. The second is safe headroom. Measuring every step of an agent’s work shows which steps are redundant and which ones keep people safe. Only the first kind should ever be cut, and capacity freed that way should be released in stages, each confirmed by a passing re-run. The third is trust that keeps up. Agents change weekly; a single report ages quickly. Re-checking on every change turns a one-off grade into a running record.

What we don’t know yet

We are early, and some questions are open. We don’t yet know how often each kind of failure occurs across the agents being deployed today; our Lab tells us that our verdicts are calibrated, not how common each failure is in the wild. We can’t yet test long chains of actions, or tools that call other agents, as safely as we would like, so we don’t claim to. And no test of a sandbox fully predicts behaviour in production, with real data and real load.

We will publish what we learn about these questions as we learn it, including when it shows our own methods falling short.

How we work

A person approves every test plan before anything runs. Our tests only update or delete objects we created and can prove are ours, and nothing we do reaches a real person outside the test account. Credentials never appear in our transcripts, reports or logs. Paying for a test does not change its verdict. These rules are set out in full in our commitments.

We started Suncly in Tallinn in October 2026, after sketching, in a networking course at TalTech, what a protocol stack for agents should look like, and finding that the protocols were arriving faster than the means to check them. We would rather build the inspection step now than explain later why there wasn’t one.