Arcade: Building a Security Control Plane for the Age of AI-Generated Code
Arcade is a security-focused Agent Development Environment built to help developers safely ship AI-generated software. It maps an application’s attack surface, reproduces vulnerabilities in isolated sandboxes, explains root causes, proposes tested fixes, and independently verifies that the original exploit no longer works all while keeping humans in control of high-impact decisions.
Arcade: Building a Security Control Plane for the Age of AI-Generated Code
AI has changed how software is built.
With tools such as Claude Code, Codex, and other coding agents, developers can turn ideas into working applications faster than ever. A feature that once took days can now be created in minutes. Entire applications can be scaffolded, refactored, and extended through natural-language instructions.
But this speed creates a difficult question:
How do we know that AI-generated software is safe to ship?
Traditional security scanners are useful, but they often stop at reporting a potential vulnerability. They may produce a warning, a rule match, or a severity score but leave the developer to determine whether the issue is real, how it can be exploited, what caused it, how to fix it, and whether the fix actually worked.
My team built Arcade to close that gap.
Arcade is a security-focused Agent Development Environment, or ADE, for AI-generated software. It is designed around a complete security feedback loop:
Map → Attack → Explain → Remediate → Test → VerifyInstead of simply saying that code “might be vulnerable,” Arcade aims to provide evidence:
- What part of the application is exposed
- How the vulnerability can be reproduced
- The request and response that prove the exploit
- The root cause of the issue
- A proposed fix
- A regression test
- Whether the original attack still succeeds after remediation
The goal is simple: help developers build at AI speed while shipping with security confidence.

Arcade’s marketing website was also designed and built by Ayush Agarwal (@ayushagarwalhere) with the same attention to detail as the product itself. Rather than treating the website as a basic landing page, the goal was to create a premium, polished experience that communicates Arcade’s technical depth, security-first mission, and AI-native workflow in a clear and engaging way. With a high-end visual design, carefully structured storytelling, responsive layouts, product documentation, changelog pages, enterprise messaging, and interactive calls to action, the site delivers the quality and finish of a website that would typically cost thousands of dollars to commission while being built specifically for Arcade from the ground up.
The problem: AI makes code generation fast, but security verification slow
AI coding agents are extremely effective at generating code. They can create APIs, database models, authentication flows, frontend components, deployment scripts, and infrastructure in a fraction of the time required by traditional development.
However, generated code can also introduce familiar security weaknesses:
- Missing authorization checks
- Unsafe input handling
- Injection vulnerabilities
- Secrets accidentally committed to repositories
- Incorrect security assumptions
- Insecure defaults
- Overly permissive infrastructure permissions
- Vulnerable dependencies
- Business logic flaws that static rules cannot fully understand
The problem is not only detecting these issues. It is validating whether they are exploitable in the context of the actual application.
Security teams and developers need more than a list of warnings. They need a workflow that connects detection to proof, remediation, and verification.
That became the foundation of Arcade.
The Arcade security loop
Arcade is organized around five specialized agents, each responsible for a different stage of the security process.
1. Mapper: Build the attack-surface map
The Mapper indexes a project and identifies the important parts of the application:
- Routes and endpoints
- Input boundaries
- Authentication and authorization logic
- Database access
- External integrations
- Sensitive operations
- Potentially dangerous code paths
The result is an attack-surface map that gives the rest of the system context. Instead of examining isolated lines of code, Arcade can reason about how the application is structured and where an attacker might enter.
2. Attacker: Reproduce the vulnerability
The Attacker attempts to reproduce a finding inside a disposable sandbox.
This is an important distinction. Arcade does not treat every scanner result as a confirmed vulnerability. It tries to demonstrate the issue with evidence.
The attacker can produce artifacts such as:
- Reproduction steps
- HTTP requests
- HTTP responses
- Command output
- Relevant source locations
- Failure or success conditions
The attacker runs inside a Docker-based environment with:
- No network access after setup
- No real secrets
- A throwaway filesystem
- No host mounts
- No additional capabilities
- Disposable credentials
The sandbox creation process snapshots the project, withholds secret files, detects the stack, creates an isolated container, copies the project into it, installs dependencies, and then disconnects the network.
This design was one of the most important challenges in the project. Running untrusted code—even code generated by an AI agent—requires strong boundaries. Arcade treats scanned projects as untrusted input and makes isolation part of the product rather than an afterthought.
3. Defender: Trace the root cause
Once a vulnerability is reproduced, the Defender investigates why it exists.
It connects the observed behavior to the underlying implementation and ranks possible mitigations. This helps transform a vague security warning into an actionable explanation.
A developer should be able to understand:
- Which input is unsafe
- Where validation or authorization is missing
- Which component is responsible
- Why the vulnerable behavior occurs
- What types of fixes are appropriate
- What risks a proposed fix might introduce
4. Remediator: Write the fix and a regression test
The Remediator creates a fix in its own worktree and adds a regression test intended to prevent the issue from returning.
This separation is intentional. The remediation step should not silently modify the developer’s project or merge changes without review.
Arcade treats security automation as an assistant, not an autonomous authority.
5. Verifier: Independently test the fix
The final step is independent verification.
The Verifier re-runs the original attack against the remediated code. It does not simply trust that the patch looks correct or that the regression test passes. It checks whether the original exploit still works.
This creates a stronger security guarantee:
A vulnerability is not considered resolved merely because a patch was generated. It is resolved when the original attack no longer succeeds.
Evidence instead of guesses
One of Arcade’s core design principles is that security findings should be supported by evidence.
A typical finding can include:
- The vulnerable file and line number
- The attack surface involved
- The exploit or reproduction steps
- The request and response proving the behavior
- The root-cause explanation
- The remediation diff
- The associated regression test
- The independent verification result
This approach helps reduce two common problems in automated security tooling:
- False positives that create alert fatigue
- Unverified fixes that create a false sense of security
Arcade does not try to replace security expertise. Instead, it makes the evidence easier to understand and gives developers a structured path from finding to verified fix.
Human approval is part of the architecture
Security automation becomes dangerous when it is allowed to make irreversible decisions without oversight.
Arcade therefore includes explicit approval gates. Agents can request actions, but people must approve high-impact operations such as:
- Applying a remediation
- Changing configuration
- Committing changes
- Merging a fix
- Performing destructive operations
- Shipping a change
The API enforces the distinction between an agent requesting approval and a person making the decision. API tokens can open and poll approvals, but only authenticated users can approve or reject them. More sensitive actions require appropriate permissions.
This was a key product and architecture decision:
Agents should investigate and recommend. Humans should approve consequential actions.
The result is a workflow that combines automation with accountability.

Building the platform with TypeScript
Arcade is structured as a TypeScript monorepo using npm workspaces.
The main applications include:
- Marketing site — the public landing page and product documentation
- ADE — the browser-based security workbench
- API — the backend for organizations, projects, runs, findings, approvals, and audit events
- Mobile app — a companion experience for reviewing security runs and approval requests
The shared packages provide the core building blocks:
-
@arcade/core— data models, scanning, run engine, workspace abstractions, and GitHub file systems
-
@arcade/agents— Mapper, Attacker, Defender, Remediator, Verifier, and model providers
-
@arcade/orchestrator— the pipeline and live engine that execute the agent workflow
-
@arcade/ui— shared components, hooks, and theme
-
@arcade/cli— command-line tools and MCP server support
The dependency direction is deliberately simple:
apps/* → orchestrator → agents → core
apps/* → ui → corePackages do not import from applications, which helps keep the architecture modular and makes it easier to reuse the same core engine across the web ADE, desktop application, mobile experience, CLI, and future integrations.
A web, desktop, mobile, and agent-native experience
Arcade is not limited to one interface.
Browser-based ADE
The main ADE runs in the browser and provides an interactive security workflow. Developers can open a local folder, inspect findings, review evidence, approve fixes, and follow the complete security loop.
Desktop application
Arcade also ships as an Electron desktop application. The desktop version bundles the ADE and runs the static application through a privileged
app:// protocol.This allows the application to work fully offline and provides a natural environment for local development workflows.
The desktop build supports:
- Windows portable executables
- Windows installers
- macOS DMG builds
- Linux AppImage and Debian packages
GitHub integration
Arcade can connect to GitHub and read repositories directly through the GitHub API without cloning them locally.
This created an important security and usability challenge: the tool needed to support repository analysis while minimizing unnecessary credential exposure.
The current design supports:
- Personal access tokens
- Desktop-only GitHub device flow
- Encrypted desktop token storage through the operating system keychain
- Browser token storage in local storage
- Direct repository reads through the GitHub API
Mobile companion
The mobile app allows developers to:
- Watch a security run
- Read evidence
- Review fix diffs
- Respond to approval gates
This is useful for teams where security decisions should not depend on being at a developer workstation.
CLI and MCP server
Arcade is also designed to be driven by other agents.
The CLI supports commands such as:
node packages/cli/arcade.mjs scan .
node packages/cli/arcade.mjs findings
node packages/cli/arcade.mjs evidence ARC-001
node packages/cli/arcade.mjs verify ARC-001
node packages/cli/arcade.mjs status --jsonArcade also exposes its workflow through the Model Context Protocol. Coding agents can connect to Arcade and use tools such as:
-
arcade_scan
-
arcade_get_attack_surface
-
arcade_get_findings
-
arcade_get_evidence
-
arcade_run_attack
-
arcade_request_approval
-
arcade_verify_fix
-
arcade_get_status
This means Arcade is not only a user interface. It is also a security control plane that other AI coding systems can interact with programmatically.
Using AWS to build and ship Arcade
AWS provides the backend foundation for Arcade.
The infrastructure is defined with AWS CDK, allowing the entire stack to be represented as version-controlled TypeScript code rather than manually configured in the console.
Arcade uses:
- AWS Lambda for the serverless API
- Amazon DynamoDB for organizations, projects, runs, findings, approvals, usage, and audit events
- Amazon Cognito for user authentication
- Amazon Bedrock for Claude-powered security explanations and remediation proposals
- AWS IAM for tightly scoped permissions
- Lambda Function URLs to expose the API
The API is built with Hono and runs locally on Node.js or remotely on AWS Lambda.
A major goal was to make local development possible without requiring an AWS account. Developers can run the API with:
- An in-memory store
- Local development authentication
- The model disabled
- DynamoDB Local when persistence is needed
This makes the project easier to test and develop while still providing a clear path to deployment.
The AWS architecture also enforces several important security boundaries.
Tenant isolation
Every DynamoDB partition key begins with the organization ID, and every store method requires the organization context. Non-members receive a
404 response instead of a 403 , preventing organization IDs from being probed.Secrets never reach the model
Before source code is sent to Bedrock, Arcade passes it through a redaction layer. Secrets are removed while preserving line numbers so that model output can still map back to the original source.
Append-only audit trail
Security actions are recorded as events. The data model does not provide update or delete operations for audit events, and writes are conditional on the event not already existing.
Controlled model spending
Each organization has a monthly model token budget. Even failed or refused model requests count toward usage because the tokens were consumed.
These controls were not added after the core product was built. They were designed into the backend architecture from the beginning.
Machine learning for reducing false positives
Arcade also includes a machine-learning pipeline for classifying scanner findings.
The objective is to distinguish real vulnerabilities from false alarms without hiding genuine security issues.
The pipeline uses:
-
microsoft/codebert-base
- Real repositories with weak labels
- Synthetic code variants with exact labels
- Frozen holdout repositories
- Continual training with replay
- Gated model promotion
- Optional SageMaker training jobs
The data pipeline generates examples by running Arcade’s actual scanner over real repositories and synthetic variants. The model is only promoted if its performance on a frozen holdout does not decline.
The product metric is especially important: if Arcade must preserve at least 99% of real vulnerabilities, how many false alarms can it safely remove?
This is a difficult problem because vulnerabilities are relatively rare in real code, while scanner rules can generate noisy results. The solution was not to pretend the data was perfect. Instead, the project uses a pipeline that can improve as more triage decisions and real-world labels become available.
The challenges behind the project
Building Arcade involved solving several problems at once.
Challenge 1: Proving vulnerabilities instead of reporting patterns
A static scanner can identify suspicious code, but it cannot always determine whether the issue is exploitable.
The solution was to combine scanning with sandboxed attacks and evidence collection. Arcade’s workflow attempts to reproduce the behavior, making findings more useful and easier to validate.
Challenge 2: Running untrusted code safely
Security testing often requires executing the application. But the application may contain malicious or unsafe code, especially when it has been generated or modified by an AI agent.
Arcade addresses this with Docker-based disposable sandboxes, withheld secrets, no host mounts, isolated credentials, and network disconnection after dependency installation.
Challenge 3: Preventing AI agents from making unsafe changes
An autonomous agent that can modify code, alter infrastructure, or merge changes creates obvious risks. Arcade handles this with approval gates and clear separation between agent requests and human decisions.
Challenge 4: Protecting secrets from AI models
Source repositories can contain credentials, tokens, private URLs, and other sensitive information.
Arcade redacts secrets before sending code to Bedrock and maintains source line numbers so security analysis remains useful without exposing unnecessary credentials.

Those questions turn security from a final checkpoint into a continuous engineering workflow.
Arcade helps developers build at AI speed and ship with security confidence.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article