Service

AI & LLM Application Security

We test the application you built around the model, not the model itself. Most AI incidents are not clever jailbreaks. They are an agent with database access and no authorisation checks, doing exactly what somebody asked it to.

Detail

Agent tool permissions and excessive agency, prompt injection traced through to real impact, retrieval and vector store data separation, unsafe handling of model output, provider key scoping, and the exposure created by agent and MCP infrastructure.

What we cover

Excessive agency

What the model is permitted to do, which tools it can call, and whether those tools check authorisation themselves or trust the agent to have done it.

Prompt injection impact

Not whether a prompt can be manipulated, because it can. What an attacker reaches once it is, through the tools and data the agent can touch.

Retrieval and tenancy

Whether a retrieval pipeline or vector store can return another tenant's documents, which is the familiar broken object level authorisation problem in an unfamiliar place.

Output handling

Model output rendered into a page, a shell, a query or a downstream API without escaping or validation, which is injection with extra steps.

Keys and secrets

Provider API key scoping and spend limits, credentials reachable through the agent, and secrets pasted into system prompts where they are one disclosure away from public.

Agent infrastructure

Tool and MCP server exposure, agent identity and delegated permissions, and what one compromised agent reaches in a multi-agent setup.

A great deal of AI security coverage is about the model. Jailbreaks, refusals, alignment, clever phrasing that makes a chatbot say something embarrassing. That work has its place and it is not what we do.

The incidents that cost organisations money look different. Somebody connected a language model to an internal system, gave it a tool that can read the database or fetch a URL, and never revisited who is allowed to make it do what. There is no exotic attack involved. The agent does exactly what it was asked, because nothing in the application was built to refuse.

The bugs are old, the surface is new

OWASP published the 2026 edition of its Top 10 for LLM Applications in August 2026. Prompt injection remains at number one, but the change worth noticing is excessive agency, which climbed three places to number three, specifically because applications now give models tools and let them act on external systems.

Read that list as a security tester rather than as an AI practitioner and most of it is familiar. Sensitive information disclosure is data exposure. Excessive agency is broken function level authorisation. Vector and embedding weaknesses are, in practice, the same multi-tenant separation failure we look for in any API. Improper output handling is injection. Supply chain is dependency management.

We have found those bugs for years in PHP applications, mobile backends and infrastructure. An agent that fetches an attacker-controlled URL is server-side request forgery. Model output written into a page unescaped is cross-site scripting. Both appear in our published case study, in an application with no AI in it at all.

What is genuinely new is the shape of the attack surface: natural language as an untrusted input that reaches a tool-calling loop, and a permission model that is frequently implicit rather than written down anywhere.

What we do not do

We are not a machine learning research outfit. We do not do model alignment work, jailbreak research, fine-tuning safety or anything that involves evaluating the weights themselves. If what you need is a red team against a model you are training, we are the wrong people and we will tell you so.

What we test is the software around it: the routes, the tools, the retrieval layer, the keys, the permission boundaries, and what an ordinary user can reach by asking nicely.

Where this sits alongside our other work

The tools an agent calls are usually an HTTP API, so this work overlaps heavily with our API and GraphQL testing, and the two are often scoped together. If the application is PHP or Laravel and we have source access, the code audit tells us why a tool behaves the way it does rather than leaving us to infer it from responses. For teams shipping AI features continuously, the rules we write for static analysis in your pipeline can catch unsafe model call patterns and secrets in prompts on the pull request that introduces them.

There is also a human parallel worth stating plainly. Prompt injection is social engineering pointed at a machine: a convincing instruction from an untrusted source, arriving through a channel the system was built to trust. We have been testing the human version for years, and the mitigations rhyme. Do not rely on the target recognising a malicious instruction. Constrain what acting on one can achieve.

What you get

01

A written report mapped to the OWASP Top 10 for LLM Applications (2026) and, where agents are involved, the Agentic Applications list

02

A reproducible proof of concept for every exploitable finding, demonstrated against a non-production environment

03

A permission review of each tool the agent can call, with recommended scoping

04

Remediation guidance aimed at the application and its authorisation model rather than at prompt wording

05

A follow-up review of your fixes once remediation is complete

Every engagement starts with a conversation about scope. Tell us what you have built and what worries you about it, and we will tell you what a useful assessment looks like.