The Burp Suite for AI Agent MCP server bridges Burp Suite and AI agents, enabling automated penetration testing by capturing and analyzing HTTP traffic, managing tasks and findings, and interacting with Burp tools. Key capabilities include:
Monitoring bridge connection and statistics (burp_status)
Listing and filtering captured HTTP requests (burp_requests)
Viewing full request/response details (burp_request_detail)
Enumerating unique endpoints with parameters and hit counts (burp_endpoints)
Listing scan/plan/scope tasks from Burp (burp_tasks)
Viewing and importing security findings as Burp issues (burp_issues, burp_import_issue)
Retrieving session snapshots (cookies, storage) (burp_snapshot)
Sending actions to Burp: open in Repeater, add scan issue, log messages (burp_send_to_burp)
Checking pending outbound actions (burp_outbound_status)
Clearing all captured data (burp_clear)
Provides tools to capture HTTP requests, analyze endpoints, queue security scans, import issues, and send actions to Burp Suite (Repeater, Scanner, etc.) through a two-way MCP bridge.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Burp Suite for AI Agent list captured requests"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
burpsuite-for-ai-agent/
āāā src/
ā āāā index.js ā MCP server (HTTP bridge + 11 MCP tools)
āāā plugin/
ā āāā burpAI.py ā Jython 2.7 Burp plugin (context menu, auto-forward, outbound polling)
āāā package.json ā Node.js manifest (dependencies: @modelcontextprotocol/sdk, zod)
āāā .gitignore
āāā README.mdRelated MCP server: ZAP MCP Proxy
Burp Suite (Linux / Windows)
āā plugin/burpAI.py (Jython plugin)
ā POST /ingest (127.0.0.1:9999)
ā GET /burp/outbound (poll every 2s)
ā¼
src/index.js ā MCP server (HTTP bridge + 11 MCP tools)
ā
ā¼
AI Agent āā MCP toolsLinux: Burp + server + agent ā all on one machine. Windows + WSL: Burp on Windows, server + agent in WSL over localhost.
bash install.shThis runs npm install, prints Burp plugin instructions, and generates .mcp.json for AI agent auto-registration.
node src/index.jsBurp Suite ā Extensions ā Installed ā Add
Extension type: Python (requires Jython 2.7 standalone JAR)
File: plugin/burpAI.py
In Burp's burpAI tab, click Check Status. Connected:
{ "ok": true, "requests": 0, "endpoints": 0 }Tool | Description |
| Bridge connection status + store statistics |
| List captured HTTP requests (filter by url/method) |
| Full request/response (headers, body) |
| Unique endpoints with parameter names, hit counts |
| Scan/plan/scope tasks queued from Burp context menu |
| Security findings queued for Burp import |
| Submit a finding (title, url, severity, detail) |
| Latest session snapshot (cookies, storage) |
| Queue action: send_to_repeater, add_scan_issue, console_log |
| Modify captured request ā send to Burp Repeater |
| Pending outbound actions |
| Run nuclei scan against a single URL |
| Run nuclei scan against all captured endpoints |
| List/display nuclei scan results |
| Import nuclei findings as Burp issues |
| Clear all captured data |
Right-click a request in Burp (Proxy/Repeater) ā burpAI: send request(s)
Agent:
burp_requests ā list captured requests
burp_endpoints ā enumerate endpoints
burp_request_detail ā full request/response
Right-click ā burpAI: send + queue scan
Agent picks up via burp_tasks.
Agent calls burp_import_issue ā Burp tab ā Import Issues
Agent calls burp_send_to_burp with type send_to_repeater ā Burp opens Repeater tab.
This is the core custom scanner flow: Burp captures ā agent thinks ā agent modifies ā Burp executes.
Burp (Proxy ā History)
ā right-click ā burpAI: send request(s)
ā¼
MCP server āāā captures request
ā
ā¼
Agent reads via burp_requests / burp_request_detail
ā
ā Agent thinks: "endpoint /api/login takes username, try SQLi"
ā
ā¼
Agent calls burp_replay({
request_id: "burp:burp-12345",
set_body: '{"username":"admin\\' OR 1=1--","password":"x"}'
})
ā
ā¼
MCP server ā Burp Repeater ā Burp executes HTTP call
ā
ā¼ (auto-forward enabled)
Response captured back ā Agent reads & analyzes
ā
ā¼
burp_import_issue ā if vulnerableKey tool: burp_replay takes a captured request ID, applies modifications (method, path, headers, body), and sends it to Burp Repeater. No need to manually craft raw bytes ā the agent just specifies what to change.
Requirements:
Enable Auto-send Repeater responses in Burp plugin settings
This ensures the agent sees every Repeater response automatically
Optionally run nuclei scans directly from the bridge:
Tool | Use case |
| Scan one URL with nuclei templates |
| Scan all captured endpoints at once |
| Review scan history |
| Import nuclei findings as Burp issues |
Nuclei must be installed on the same machine. Findings with High/Critical severity are auto-imported as Burp issues.
Feature | Description |
Auto-send Proxy responses | All Proxy traffic sent to MCP server |
Auto-send Repeater responses | Repeater traffic automatically forwarded |
Forward Burp Scanner issues | Scanner findings pushed to agent |
Auto import issues | Pull agent findings on context menu |
node src/index.js --port 9999 # Custom port (default: 9999)
node src/index.js --db /path/to/data.json # Persistence file (default: burpai-data.json)
node src/index.js --port 9001 --db custom.jsonData persists across restarts when --db is set (or by default). The server auto-saves on every mutation and loads data on startup.
Burp plugin URL configurable from the burpAI settings tab in Burp.
Node.js 18+
Burp Suite (Community or Professional)
Jython 2.7 standalone JAR (configured in Burp Extensions ā Environment)
Clear all captured requests, endpoints, tasks, and issues from the bridge store.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'Clear', implying destruction, but does not mention permanence, required permissions, or side effects (e.g., whether data is recoverable). Missing critical behavioral context for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, well-structured sentence with no unnecessary words. It efficiently conveys the action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what the tool does (clears various resources) but lacks details on return value or side effects. Given the tool's simplicity and no parameters, it is mostly complete, though adding a note about irreversibility would improve it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, so schema coverage is 100%. The description adds no parameter information, but none is needed. Baseline for zero parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool clears all captured requests, endpoints, tasks, and issues from the bridge store. It uses specific verb 'Clear' and lists the resources, distinguishing it from sibling tools that retrieve or import data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. Sibling tools like burp_status or burp_requests provide read capabilities, but the description does not advise on appropriate context or when not to use this destructive action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List unique endpoints (METHOD + path) observed from Burp traffic, with query/body parameter names and hit counts. Helps identify attack surface.
| Name | Required | Description | Default |
|---|---|---|---|
| method | No | Filter to a single HTTP method | |
| url_contains | No | Filter to endpoints whose URL contains this substring |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It reveals the output includes method, path, parameters, and counts, but does not disclose data freshness, caching, or session scope. Adequate but not detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first defines functionality, second states purpose. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description sufficiently describes output fields. Does not mention pagination or limits, but for a list tool, it covers the essential information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description adds no new meaning beyond the parameter descriptions in the schema. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists unique endpoints (METHOD + path) from Burp traffic with parameter names and hit counts. Distinguishes from sibling tools like burp_requests, which lists individual requests, and burp_issues, which lists vulnerabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies use for attack surface identification but lacks explicit when-to-use or when-not-to-use guidance. No alternatives mentioned despite sibling tools like burp_requests.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submit a confirmed finding as a Burp-importable issue. The issue will appear in the bridge and can be pulled into Burp via the burpAI Burp plugin.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Full URL where the finding was discovered | |
| title | Yes | Finding title (e.g., "SQL Injection in login parameter") | |
| detail | Yes | Detailed description of the finding with impact | |
| method | No | HTTP method (GET, POST, etc.) | |
| severity | No | Severity: Critical, High, Medium, Low, Information | |
| parameter | No | Affected parameter name | |
| remediation | No | How to fix the issue | |
| rawRequestB64 | No | Base64-encoded raw HTTP request for Burp replay | |
| rawResponseB64 | No | Base64-encoded raw HTTP response |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It discloses that the issue appears in a bridge and can be pulled via plugin, but lacks details on side effects, idempotency, or required permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no waste. The first sentence covers the primary action, the second adds integration context. Efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 9 parameters and no output schema, more context is needed about the bridge, plugin workflow, and prerequisites. The description covers the basic flow but lacks depth for a complex import tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter already has a description. The tool description adds no additional meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Submit a confirmed finding as a Burp-importable issue') and mentions the plugin integration, clearly distinguishing from listing or sending tools. However, it doesn't explicitly differentiate from burp_send_to_burp.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs. alternatives like burp_send_to_burp. No prerequisites or conditions mentioned. The description only implies it's for confirmed findings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List security findings/issues queued for Burp import. These are confirmed findings that can be imported as Burp Scanner issues.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It indicates a read-only operation ('List') and adds context that findings are 'confirmed' and 'can be imported.' Could mention absence of side effects or what happens if queue empty, but is adequate for a simple list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with purpose, no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description sufficiently explains what is listed and the context (queued for Burp import, confirmed). Could mention that output is an array, but given low complexity, it is complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema (100% coverage), so baseline is 4. Description does not need to add param info; it adds no harmful information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists security findings/issues queued for Burp import, using specific verb ('List') and resource ('security findings/issues queued'). It distinguishes from siblings like 'burp_requests' (raw requests) and 'burp_import_issue' (import action).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (queued for import) but does not explicitly state when to use vs. alternatives or when not to use. No direct comparisons to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List pending outbound actions queued for the Burp plugin to execute. Actions remain here until the Burp plugin polls and drains them.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description discloses the tool lists actions and explains that actions persist until polled and drained by the plugin, implying a non-destructive read operation with no side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, concise, front-loaded with action (List), and every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explains the lifecycle of actions adequately, but could optionally mention the format of the returned list for completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in schema; description naturally adds no parameter details but is adequate for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists pending outbound actions for the Burp plugin, using specific verb 'List' and resource 'pending outbound actions'. It distinguishes from sibling tools like burp_status which likely targets overall system status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for checking the queue of pending actions, but does not explicitly compare to siblings like burp_status or provide when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch full details for one captured request: headers, request body, and response body (when available). Pass the id from burp_requests.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Request id from burp_requests output | |
| body_max_chars | No | Cap for response body excerpt (default 4000) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions response body availability but omits details like default cap for body_max_chars (4000) or error handling. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose, no redundancy. Perfectly concise for the information conveyed.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Moderate complexity with 2 params and no output schema. Description covers main functionality and id source, but lacks details on return format or error conditions. Generally complete for a simple fetch.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds minimal value beyond the schema; it repeats the parameter purpose without elaboration.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches full details (headers, request body, response body) for one captured request, distinguishing it from sibling tools like burp_requests (list) and burp_clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to pass the id from burp_requests, providing clear usage context. Does not include when not to use, but given the tool's specificity, it is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List recent HTTP requests captured from Burp (most-recent first). Returns id, method, url, and status for each captured request.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number to return (default 50) | |
| method | No | Filter to a single HTTP method (GET, POST, PUT, etc.) | |
| url_contains | No | Filter to requests whose URL contains this substring |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the read-only nature (listing), ordering, and return fields. While it does not mention rate limits or side effects, the behavior is clearly a safe read operation, which is adequate for a list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the primary action, and contains no extraneous information. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 parameters, no output schema, no annotations), the description covers purpose, return fields, ordering, and filter hints. It does not detail the output structure, but the listed fields suffice. Minor gap: no mention of pagination beyond the limit parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for all three parameters. The description does not add significant meaning beyond the schema; it restates the return fields but does not elaborate on parameter usage or constraints. Baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List'), the resource ('recent HTTP requests captured from Burp'), and the ordering ('most-recent first'). It also specifies the return fields (id, method, url, status), distinguishing it from sibling tools like burp_request_detail which likely returns full request details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage as a list tool but does not explicitly state when to use it versus alternatives like burp_request_detail. No when-not-to-use or exclusions are provided, so the guidance is only implied through context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Queue an action for execution in Burp Suite. The next time the Burp plugin polls, it will execute the action. Supports: send_to_repeater (open Repeater tab with a request), add_scan_issue (add scan issue to Burp), console_log (write to Burp output tab).
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Finding URL (required for add_scan_issue) | |
| host | No | Target host (required for send_to_repeater) | |
| port | No | Target port (required for send_to_repeater, e.g. 443) | |
| type | Yes | Action type: send_to_repeater opens a Repeater tab; add_scan_issue adds a Scanner issue; console_log writes to Burp output | |
| https | No | Use HTTPS (required for send_to_repeater) | |
| title | No | Issue title (required for add_scan_issue) | |
| detail | No | Finding description (required for add_scan_issue) | |
| message | No | Message text (required for console_log) | |
| severity | No | Severity: Critical, High, Medium, Low, Information | |
| tab_name | No | Tab caption in Repeater (optional, for send_to_repeater) | |
| raw_request_b64 | No | Base64-encoded raw HTTP request (required for send_to_repeater) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the key behavioral trait of being asynchronous ('the next time the Burp plugin polls'), but does not cover failure handling, reversibility, or authorization requirements. Without annotations, this is a moderate disclosure but incomplete for a tool that queues actions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences. The first sentence defines the core action, and the second enumerates supported actions with brief clarifications. No redundant information is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 11 parameters, no output schema, and no annotations, the description is partially complete. It covers the purpose and action types well but omits details about return values, error behavior, or the queuing mechanism's side effects, leaving some gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, the baseline is 3. The description adds value by explaining that certain parameters are required for specific action types (e.g., 'raw_request_b64' for send_to_repeater), which goes beyond the schema's individual property descriptions and clarifies conditional usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies that the tool queues an action for execution in Burp Suite, listing three distinct action types. It distinguishes itself from sibling tools like 'burp_status' (read-only) or 'burp_clear' (removal) by explicitly stating it is for sending actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (to queue actions in Burp) but does not provide explicit guidance on when not to use it or mention alternative tools for similar purposes. The context implies usage for sending actions, but lacks exclusions or comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the most recent session snapshot (cookies, localStorage, sessionStorage). Useful for constructing authenticated requests.
| Name | Required | Description | Default |
|---|---|---|---|
| url_contains | No | Most recent snapshot whose URL contains this substring |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavioral traits. It only describes a read operation without mentioning side effects, idempotency, rate limits, or behavior when no snapshot exists (e.g., returns null). This leaves significant ambiguity for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero wasted words, front-loaded with the key action and resource. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (1 optional param, no output schema). The description covers purpose and a use case but omits the return format/structure (how cookies and storage are represented) and behavior for missing snapshots. Adequate but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameter `url_contains` is already documented in the schema. The tool description adds no additional meaning or context beyond what the schema provides, meeting the baseline but not exceeding it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the most recent session snapshot, specifying the resource (cookies, localStorage, sessionStorage) and action. This distinctly distinguishes it from sibling tools like burp_requests (list HTTP requests) and burp_issues (security issues).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions the tool is 'useful for constructing authenticated requests,' providing clear context. However, it does not specify when not to use it or compare to alternatives like burp_requests for older snapshots.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show Burp bridge connection status and store statistics (requests, tasks, issues captured). Call first to confirm bridge is running.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It does not disclose whether the tool is read-only or has side effects (e.g., 'store statistics' could imply mutation). No mention of auth, rate limits, or what happens if bridge is down. Brief and lacks behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose and usage guidance. No wasted words; every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, so description should explain return values. Mentions 'store statistics' but doesn't describe format or contents. For a simple status check, this might be adequate, but lacks detail on what the response contains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, baseline is 4. Description adds nothing about params, but none exist, so it's sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it shows bridge connection status and stored statistics, and explicitly says to call first. Specific verb 'Show' and resource 'bridge connection status, store statistics' differentiate from sibling tools like burp_requests (list requests) or burp_issues (list issues).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Call first to confirm bridge is running', which is clear guidance on when to use. Does not mention when not to use or alternatives, but the sibling context makes it obvious that this is the health check tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List scan / plan / scope tasks queued from the Burp extension. Use these to decide what to analyze next.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It indicates a read-only list operation ('list ... tasks queued'), but does not disclose authentication needs, rate limits, or any side effects. Sufficient for a simple list, but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action. No extraneous information. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description is nearly complete. It states purpose and usage. However, it could mention if the list includes status or ordering, but this is minor given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has zero parameters, and schema description coverage is 100%. The description does not need to add param info; baseline is 4. It correctly implies no parameters needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'list' and the resource 'tasks', specifying types: scan, plan, scope. It distinguishes from sibling tools like burp_requests, burp_status, etc., by focusing on listing queued tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context: 'Use these to decide what to analyze next.' It implies when to use, but does not explicitly state when not to use or provide alternative tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0burp_clearburp_endpointsburp_import_issueburp_issuesburp_outbound_statusburp_request_detailburp_requestsburp_send_to_burpburp_snapshotburp_statusburp_tasksScored across 11 tools
Each tool targets a distinct aspect of the Burp Suite integration: clearing, status, requests (list/detail), endpoints, tasks, issues (list/import), session snapshot, and outbound actions (send/status). Despite some related operations, the descriptions clearly differentiate them, leaving no ambiguity.
All tools follow a consistent 'burp_' prefix with snake_case names. Verbs and nouns are used predictably (e.g., burp_clear, burp_requests, burp_import_issue). There is no mixing of conventions, ensuring easy pattern recognition.
With 11 tools, the set is well-scoped for a Burp Suite bridge. It covers essential operations without being bloated or sparse. Each tool serves a clear purpose, and the count aligns with the expected complexity of security testing workflows.
The tool set covers the core workflow: connection status, request capture, endpoint discovery, task and issue management, import, session retrieval, and outbound actions. Minor gaps exist, such as the lack of detailed views for individual tasks or issues, but these do not critically hinder the primary use case.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Zero-setup MCP gateway securely connecting AI to your tools with authentication and workflows
MCP server for Pentest-Tools.com: run scans, manage findings and reports via your preffered LLM.
Talk to your public-facing AI from any MCP client ā Claude, ChatGPT, Cursor, Cline, Windsurf.
Human-input bridge for AI agents with voice-first answer links, MCP tools, and HTTP APIs.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/whoismemas/burpsuite-for-ai-agent'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
