AI Agent Browser Runtime: A Local DevTools Evidence System Built for Agents and Application Security

This article introduces agent-browser-runtime—a local browser runtime environment designed specifically for AI agent and application security workflows. By providing DevTools-level browser control capabilities, it addresses the limitations of traditional automation tools (such as context loss, difficulty in security auditing, insufficient evidence collection, and poor isolation), offering robust technical support for automated testing, security auditing, and agent interactions. Its core value lies in connecting AI capabilities with the Web world, enabling the building of smarter and more secure software systems.

As AI agents become more capable, their interactions with Web browsers are increasingly complex (from web scraping to security auditing). Traditional browser automation tools have the following limitations:

• Context loss: High-level APIs cannot access detailed internal browser states, making fine-grained decision-making difficult;
• Difficulty in security auditing: It is hard to deeply inspect details like DOM, network requests, and JS execution;
• Insufficient evidence collection: Lack of detailed operation records in security auditing/compliance scenarios;
• Insufficient isolation: Cannot effectively protect the host system when running untrusted code.

The agent-browser-runtime project was created to solve these problems.

Core Design Philosophy

Centered on "DevTools as a Service", it programmatically exposes browser developer tool capabilities:

• Full browser control: Deep access to network requests, JS execution context, storage status, etc.;
• Fine-grained evidence collection: Records complete audit trails such as DOM snapshots, network traffic, and console logs;
• Secure isolated runtime: Sandboxed environment to protect the host system;
• Agent-friendly interface: Supports natural language operation intentions, reducing interaction cognitive burden.

Technical Architecture

Built on Chromium and Chrome DevTools Protocol (CDP), key components include:

• Browser engine layer: Headless Chromium, supporting headless/UI debugging modes;
• CDP bridge layer: Encapsulates CDP into easy-to-use high-level APIs;
• Evidence recorder: Monitors and structurally stores browser activities;
• Agent interface layer: Converts natural language instructions into browser operations;
• Security sandbox: Implements isolation through containerization + permission control.

A notable feature of agent-browser-runtime is the full programmatic access to DevTools capabilities:

• Network monitoring: Captures HTTP/HTTPS request and response details, supports interception and modification;
• DOM inspection: Obtains the complete DOM tree, supports CSS selector/XPath positioning;
• JavaScript debugging: Executes code, sets breakpoints, and views variable states;
• Performance analysis: Collects page loading/JS execution/rendering performance data;
• Storage inspection: Accesses and modifies LocalStorage, Cookies, etc.;
• Security panel: Checks HTTPS certificates, CSP, mixed content warnings, etc.

In application security (AppSec) workflows, this system can perform various automated tests:

• Vulnerability scanning: Traverses pages/forms to identify vulnerabilities like XSS, SQL injection, CSRF;
• Authentication testing: Tests login/registration/password reset flows, checks brute force attacks, session fixation, etc.;
• Authorization testing: Verifies access control, tests horizontal/vertical privilege escalation;
• Sensitive data detection: Scans for sensitive information leaks in pages/JS/network traffic;
• Compliance checks: Automatically checks security controls according to standards like OWASP ASVS, NIST.

All testing activities generate complete evidence chain reports, meeting compliance audit requirements.

Provides natural Web interaction capabilities for AI agents:

• Visual understanding support: Captures page screenshots, cooperates with multimodal AI to understand visual content;
• Natural language operation: Converts instructions like "click the login button" into browser operations;
• State awareness: Queries current browser states (URL, title, elements, etc.) to assist decision-making;
• Error recovery: Provides detailed error information to support strategy adjustment or human assistance;
• Multi-tab management: Supports parallel processing and task switching across multiple tabs.

Comprehensive evidence collection and audit tracking capabilities:

• Operation logs: Records timestamps, operation types, target elements, results, etc.;
• DOM snapshots: Captures the complete DOM state at key operation points;
• Network traffic records: Fully records request responses, supports HAR format export;
• Screen recording: Optional video recording of operation processes;
• Console logs: Captures browser console output;
• Security events: Records security events like certificate errors, CSP violations.

All evidence is stored structurally, supporting multi-dimensional query and export.

Deployment and Usage Recommendations

• Containerized deployment: Use containers to ensure environment consistency and isolation;
• Resource limits: Set CPU/memory/network resource limits;
• Network policies: Configure strict outbound network policies, optional proxy for traffic monitoring;
• Evidence retention: Establish a retention policy with encrypted storage and access restrictions;
• Monitoring and alerts: Set up alerts for abnormal behaviors (CPU/traffic anomalies, crashes).

Conclusion

agent-browser-runtime represents an important direction in browser automation technology. By empowering AI agent interactions, application security testing, and automated auditing with DevTools-level capabilities, it serves as a bridge connecting AI and the Web world, paving the way for building smarter and more secure software systems.