Harness Your Mechs: What to build & what to buy when you bring AI into AppSec

Explore the resource kit now: the playbook, research, and ROI calculator for bringing AI into AppSec.

A security engineer on your team spends a few weekends building an agent. It reviews pull requests, traces findings back to their source, and drafts fixes. On the repo they tested it against, the demo goes great. Someone drops a Yoda emoji in Slack.

Then platform engineering asks the question that follows every good demo: "Can we run this across all 2,000 repos? And every PR?"

Congratulations. You now own security infrastructure.

An agent that works for one security engineer, on one repo, on one task is a very different thing from a security system that has to hold up across every repo and pull request in an enterprise. At that scale, costs compound, every finding needs verification, and sooner or later someone asks for evidence that all this spend is actually making software safer.

That gap is why we're launching the Harness Your Mechs campaign today. This campaign includes a resource kit that takes on one practical question: how do you architect security into the agentic SDLC, from code generation through review, release, and remediation in a cost effective and scalable manner?

Security agents are cheap to prototype. Running them at scale isn't.

Frontier models reopened the AppSec tooling conversation fast. In IDC's July 2026 survey, about 80% of respondents said frontier AI security capabilities are prompting at least a moderate reassessment of their dedicated AppSec tools, and nearly half expect to cut, consolidate, or replace at least one.

That reassessment is healthy. Frontier models are greatly useful, especially for targeted penetration testing at critical release points. But enterprises also need to secure code as it's generated and scan their codebases continuously, and that's where the economics of a prototype get concerning.

Early studies point to the same weak spot: agentic AI projects don't usually fail at the demo. They fail during scale, when costs and risk start to add up. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, and the reasons it names are escalating costs, unclear business value, and inadequate risk controls. Not one of them is "the model wasn't smart enough." Security teams are seeing the same drop off. In Prophet Security's 2026 survey, 46% of respondents who attempted internal AI tooling for the SOC had deprecated it, replaced it, or never brought it into production. These weren't ideas on a whiteboard. Teams built them, then didn't keep them running. That's the SOC, not AppSec, but we wouldn't bet against the pattern carrying over.

When an agent leaves the demo repo, three costs start to compound.

Tokens. Without security context, an agent has to work out reachability, exploitability, and remediation from scratch on every question. In our research report, The Token Economics of AI AppSec Agents, we ran 34 everyday AppSec prompts across 12 open-source projects using the same model in two setups: one with precomputed evidence from Endor Labs, and one working from the repository and the web. The unaided agent burned 79.5 million tokens over 370 minutes. The agent with evidence used 6.6 million, about 12x fewer, and finished in 133 minutes. Its spend was also steadier: costs varied 1.8x between small and large projects, versus 4x for the unaided agent.

To put dollars on it, we ran a mid-size engineering org through our Agentic Remediation Token ROI Calculator: 300 code contributing developers, each shipping three security fixes a month (well under the industry average of about two a week). That's 10,800 fixes a year. With agents working unaided on Claude Opus 5, the annual remediation bill comes to about $5.8M. With precomputed security context cutting token use by 80% (a conservative setting; we measured up to 91.7%), it drops to about $1.4M. Move to a pricier model and the gap widens: on Claude Fable 5, it's $11.2M versus $2.5M. And that's the bill for running agents, before anyone is paid to build or maintain what they run on. These estimates use public model pricing as of September 2026; your numbers will vary with repo size, fix complexity, and model choice.

Verification. Finding a potential vulnerability creates work before it produces a security outcome. One study of agentic software development found automated code review consumed about 59% of tokens, versus about 9% for initial code generation. And those findings need scrutiny: Comcast found that 44% of critical and high-severity AI findings that completed validation were false positives. Every one of those is a person (or another agent) chasing a ghost.

Correctness. Agents still lag on security. On our Agent Security League leaderboard, the top coding agent reaches 87% functional correctness but only 37% security correctness. Passing the tests and passing the pen test are still two different achievements.

Two caveats, because we'd be suspicious of us too. The token study is a cost benchmark, not an accuracy benchmark. And our evidence is precomputed, which isn't free; what we measured is marginal cost per question, which is what matters when you're running a fleet of agents. The full methodology is in the report.

None of this means teams shouldn't build. It means build vs. buy is now an architecture question: which layers should your team build, which capabilities should your agents call, and what belongs in the harness around the model?

Four levels for architecting security into the agentic SDLC

Most AppSec teams don't lack ambition. They lack a map. The applied AI playbook for AppSec lays out four levels of AI maturity and scores them across two tracks. The Secure track covers the code your developers' AI agents write. The Defend track covers AI doing AppSec work: finding, triaging, and fixing. A team can be building its own triage skills while developers' coding agents still run on personal accounts, and a single score would hide that.

Level 1: Governed generation. Developers use approved coding agents through company accounts, you keep an inventory of every agent, model, MCP server, and skill in use, and security guidance reaches agents as code is written, through rules files, hooks, and MCP servers. Your team's role is operator, and the answer is mostly buy; what you build is policy. Fair warning: you can't govern what you can't list, and the list is usually longer than anyone expects.

Level 2: Agentic security tools. Purpose-built agents find, verify, triage, and fix vulnerabilities, and people approve what they propose. The difference from Level 1 scanning is verification: findings arrive with evidence that the issue is real and reachable before a developer ever sees them. Your team's role is approver, and the answer is still mostly buy. The question to ask any vendor: does every finding come with evidence you can verify, or just a confident tone?

Level 3: Custom security skills. Your team builds skills that encode how your organization does one security task: your triage rules, your fix conventions, your threat model, and why that one legacy service is allowed to do the thing nobody else is allowed to do. Each skill gets an eval suite and an owner. Your team's role is builder, and the answer is both: build the skills, and buy the security context they call, because re-deriving it on every question is where the 12x comes from. This is where most homegrown projects stall, since it's where the token, verification, and maintenance costs above come due.

Level 4: Orchestrated security agents. Specialized agents work as a system. An orchestrator routes events, like a new pull request or a new advisory, to subagents that each do one job well, and each agent earns its autonomy one action type at a time, with a kill switch close at hand. Your team's role is overseer, and the answer is both: build the orchestration, risk model, and autonomy gates, and buy the deterministic foundation every agent calls.

Level 4 is the destination for most programs, but not every workflow needs to get there. Rare, high-impact changes, like authentication logic or cryptography, can keep a human approver indefinitely without holding the program back. The playbook walks through each level in detail: what it takes, where teams stall, what to build versus buy, a self-assessment for both tracks, and a plan for your first 90 days.

Build what's unique to your business. Don't rebuild the security foundation underneath it.

Your policies, risk tolerance, and workflows are worth building. That's where your team's hard-won knowledge lives, and no vendor can ship it to you in a box.

The layer underneath is different. Agents doing security work across every repo and PR need context (deterministic knowledge of how your code actually behaves), verification (confirmation that a finding is real), evidence (a chain you can walk an auditor through), and economics (costs that stay predictable as volume grows).

You could build that layer yourself, but know what you're signing up for. You'll need a context graph that holds up across languages, monorepos, and the refactor someone swears is the last one. You'll need an evaluation suite and continuous benchmarking to re-validate every model change. And you'll need owners who stick around after the original champion moves teams. It's less a project than a pet. A large, rancor-sized one.

That's the work we take on with you. As an applied AI lab for software security, Endor Labs brings four things:

• A playbook. A practical, level-by-level path for architecting security into the agentic SDLC, including where to build and where to buy.
• Research and evaluations. We measure what agents actually cost and catch, then publish the methods, including the results where we don't come out on top.
• Expertise. Architecture and deployment support from engineers who work alongside your team, not a handoff after the contract is signed.
• AURI by Endor Labs. The technical foundation at every level. Coding Agent Governance checks code as agents write it (Level 1). AI SAST and reachability-based software composition analysis (SCA) put evidence behind every finding (Level 2). The code context graph lets your skills look up reachability instead of re-deriving it (Level 3). And the same deterministic foundation sits under every subagent, from one repository to thousands (Level 4).

Underneath all four, AURI continuously maintains a code context graph: a function-level model of how your application behaves across first-party code, open-source dependencies, and containers. Your agents reach that evidence through hooks, skills, MCP, CLI, and API, so they spend less time excavating and more time reasoning.

Cursor's security team is a good example of what that looks like in practice. With function-level reachability, only 2.5% of their SCA findings turned out to be reachable. They fed Endor Labs data into their own AI-powered platform and built a remediation workflow that scales, without forcing risky upgrades onto product engineers. They built the part that was unique to them, on a foundation they didn't have to maintain.

"Endor Labs' unique reachability-based analysis and native integrations into our agentic software development stack keep our developers focused on rapidly finding and fixing real risks in the SDLC, so we ship faster with confidence." - Sunil Agrawal, CISO at Glean

To be clear, Harness Your Mechs isn't an anti-building manifesto. It's about where your building effort goes.

"I've been a builder my whole career, so I understand why security teams are building their own agents. But proving an agent works on one repo is a very different question from owning it across thousands of repos for years. The cost of AI is falling. The cost of running security at the scale AI makes possible isn't. That's why we run Endor Labs as an applied AI lab: we do the research, publish what we find, and work alongside teams so their best building goes into what's unique to their business." - Varun Badhwar, co-founder and CEO of Endor Labs

Once upon a codebast forest: AT and a squad of mechs

The four levels give you the roadmap. We wanted to make the journey a little more fun, so we built an entire fictional world to go with it. If there's a kid in your life who still thinks your job is "computers," this is the bedtime story that finally explains what you do all day. Every stage of the journey for AT, the Endor Labs guardian, maps to the real work of architecting security into the agentic SDLC.

It starts one evening at the base, when a blinking cursor pulls AT's staff right through his screen. He dives in after it and lands in a video game-like forest made entirely of code, one that cheerful growers make bigger every night. Getting the staff back will take a map, a squad of mechs (RNG-R, VER-8, PAT-3, and SYN-C), and a few things only AT can build himself. (Small spoiler: the answer is never a bigger core i.e. newer model)

Read the full story, Once upon a codebase forest: The story behind Harness Your Mechs.

Plan your path to Level 4

Wherever your team sits today, these resources will help you figure out what comes next:

• The applied AI playbook for AppSec: Four levels for architecting security into the agentic SDLC. What each level takes, where teams stall, and what to build versus buy, plus a self-assessment for both tracks and a plan for your first 90 days.
• Agentic Remediation Token ROI Calculator. Model what unaided agents cost at your repo size and PR volume, and take a PDF breakdown into your next budget discussion.
• AI Coding Agent Security Benchmark. Our open Agent Security League benchmark tracks 32 agent and model combinations across 200 real-world tasks. Even the top performer writes code that works 87.2% of the time, but code that's also secure only 37.4% of the time.
• Architecting security into the agentic SDLC: A walkthrough of the four-level playbook. Register for the live webinar on November 12. Bring your questions.

Over the next few weeks, we'll also publish Decoding the agent stack: What MCP servers, skills, plugins, hooks, and harnesses actually do for AppSec (October 27), 3x the findings, 12x fewer tokens: Getting more from your AppSec agents (November 2), and Why code review needs purpose-built security agents (November 10). On November 12, the maturity quiz goes live on the campaign hub so you can score your program on both tracks. And on December 2, we'll host Inside AURI: How Endor Labs secures the agentic SDLC, a live look at AURI in practice. Bring your skepticism.

Find your level

Back to that security engineer and their 2,000 repos. The agent they built is worth keeping. The real questions are what it should stand on, and what level your team reaches next.

Explore the Harness Your Mechs campaign hub for the research, the roadmap, and the tools to see where your team stands. And if you want AURI by Endor Labs as your security foundation while you build security into your agentic SDLC, talk to our team.

Mechs optional.