We’ve spent the past two years building an autonomous security agent. We’re keeping the name to ourselves for now, but we want to share some of the engineering behind it.

What we want from the project is an investigation we can follow and question. If the agent says it found a vulnerability, someone should be able to look at the evidence and decide whether that claim holds up. The model’s explanation can help, but it can’t be the only thing we have.

That requirement runs through the implementation: permission to perform a test, a record of what happened, and a separate decision about whether the result supports a finding. We’re sharing those design choices here, with no public benchmark or independent audit attached. We aren’t presenting this as a replacement for a security assessment.

What we mean by an autonomous security agent

An autonomous security agent coordinates parts of an investigation: choosing a next step, using tools, interpreting observations, and producing a report. In this project, those activities sit inside an authorized engagement with defined scope and runtime limits.

We want the software to carry more of the repetitive work while leaving a clear account of its decisions. That requires a distinction between what the model suggests and what the platform permits.

We’ve built an orchestration layer and a tool boundary, with separate safety controls, evidence handling, and validation. An operator interface and API let us work with the investigation beyond the conversation that started it.

Authorization has to survive the next tool call

A task description is not sufficient authorization. If an agent is allowed to test one application, discovering a link to another host should not expand that permission.

We keep authorization separate from model output. The implementation has signed authorization records and controls for scope, network access, redaction, and spend. When configuration layers override one another, the safety limits can tighten; a higher-precedence setting shouldn’t be able to relax them.

This gives us concrete behavior to test. An out-of-scope destination should remain out of scope even when the model has a plausible reason to investigate it. A budget limit should still apply when the next test looks promising.

We need to test those limits where the action happens. Asking the model to respect them is only part of the job.

A hypothesis needs a route to being disproved

A suspicious response is a starting point. A timeout might reflect a slow service. An error page might expose a bug without establishing the impact claimed in a report. A model’s explanation can be coherent and still be wrong.

That’s why we separate producing a hypothesis from confirming a finding. The validation path checks the evidence and controls whether we accept the result as a finding.

Our tests pair vulnerable local services with patched ones. We want the system to produce and reproduce a signal in the vulnerable case, then avoid or refute the same finding when that behavior is absent.

Those tests cover specific scenarios, so we can’t turn their existence into a general detection rate. We also want to know what would make the system withdraw a finding. If it can’t recognize the patched case, we have more work to do.

Evidence needs to travel with the finding

We can assemble a signed evidence bundle containing the run’s records, model request and response hashes, routing context, and replay information. A separate offline verifier checks its structure and integrity, checks the signature against a trusted key, and applies the specified consistency checks.

That gives a reviewer a way to detect changes to a recorded artifact and inspect whether it agrees with the finding presented. It also makes the trust setup explicit: a key the reviewer obtains through an independent trusted channel provides a different assurance from a key supplied only by the bundle itself.

We have to be precise about what that proves. A valid signature doesn’t establish that the original security conclusion was correct. Checking recorded replay information doesn’t mean we’ve tested the live system again. The environment may have changed, a credential may have expired, or the model may respond differently on a fresh run.

We keep artifact integrity, consistency of recorded evidence, and reproduction against a live target as distinct claims. A useful report should say which of those has actually been checked.

Deterministic tests answer a narrower question

For the documented internal test path, we use a deterministic model substitute. That lets us exercise the orchestration and evidence lifecycle repeatedly. We’ve also implemented integrations with model providers.

A controlled test can reveal a broken state transition or a malformed evidence bundle. It cannot establish how reliably a real model will investigate an unfamiliar application. That needs separate evaluations with known vulnerable and clean cases, fixed budgets, and a record of failures as well as successes.

We also need to account for the instructions and application context surrounding a model. Changing the provider or prompt can change behavior even when the tool interface stays the same.

What we can responsibly say today

We’ve implemented authorization, orchestration, evidence packaging, and offline verification, with tests for specific behaviors. External-client operation has separate readiness gates from internal testing. We’re not announcing unrestricted customer access or independently measured accuracy here.

Two years tells you how long we’ve been working on this. To judge how well it works, you’ll need evaluation results.

For an evaluation, we would ask whether findings reproduce, whether patched controls stay clear, whether denied actions are blocked, and whether a reviewer can follow a conclusion back to its observations. We would also record cost, elapsed time, incomplete investigations, and the work still required from a human.

We want someone reviewing a finding to be able to disagree with the agent and show why. Keeping the observations accessible, the authorization explicit, and the verification separate gives that reviewer something concrete to work with.

Security services from Libre Labs View all posts