AI Agentic Workflows
Overview
AI agents can work alongside your testers in AttackForge: enriching findings, testing, retesting, writing executive summaries and analysing attack chains. You start an agent from an AttackForge Action, and it reads and writes AttackForge data through AI MCP.
There are two ways to use AI with AttackForge:
Human in the loop: a person works with an AI assistant in a chat, using prompts and skills. See prompt and skill examples.
Agentic workflows: an AttackForge Action starts an agent, which does the work on its own and writes the results back. This page covers these.
Why it matters
Benefit
What it means
Speed and scale
Agents handle repetitive work across many projects at once.
Coverage and consistency
Every target and finding gets the same methodical treatment.
Testers do the expert work
Agents take lower-level tasks, so people can focus on judgement and depth.
Adaptive reasoning
Agents decide their next step from what they've found.
Better reporting and evidence
Agents draft writeups, summaries and evidence as they go.
Continuous and on-demand testing
Run testing when you need it, not just at a scheduled point in time.
Support for junior testers
Agents bring framework knowledge and context to every finding.
Less noise
Agents help triage, deduplicate and prioritise findings.
Who uses it
Role
Typical use
Security leaders
Scale testing and reporting without adding headcount
Testers and consultants
Hand off breadth work, then review and extend what agents find
Project managers
Start retests, summaries and attack chain analysis from a project
Automation builders
Build and host agents, and connect them to Flows and Actions
Administrators
Grant MCP tools, manage secrets, and share Actions with users
How it works
Every example on this page uses the same pattern:
A user runs an Action on a project, vulnerability or writeup.
The Action starts a Flow, which sends the record's IDs to your agent's HTTP endpoint.
The agent works on its own, using the AttackForge MCP tools you've given it.
The results appear in AttackForge: improved writeups, new vulnerabilities, updated test cases, retest outcomes, an executive summary or a workspace file.
Choose an example
Example
What the agent does
Started from
Example platform
Vulnerability enrichment
Improves writeups with MITRE CWE and CAPEC data
Projects, vulnerabilities or writeups
Microsoft Copilot Studio
Penetration testing
Tests the project scope and records vulnerabilities and test cases
A project
OpenClaw and Microsoft Foundry
Retesting
Retests vulnerabilities, then reopens or closes them
A project
OpenClaw and Microsoft Foundry
Executive summary
Drafts the project's executive summary
A project
OpenClaw and Microsoft Foundry
Attack chain analysis
Builds attack chains and saves them to the project workspace
A project
OpenClaw and Microsoft Foundry
Agentic vulnerability enrichment
An agent improves your writeups: it works out the vulnerability type, finds the relevant MITRE CWEs and CAPECs, and rewrites the writeup's fields.

What enrichment can do
Benefit
What the agent does
External context
Adds details from CVE, NVD, EPSS, CISA KEV, Exploit-DB, vendor advisories, threat intelligence and public proofs of concept
Contextual risk scoring
Adjusts severity for the asset, exposure and exploitability
Deduplication
Groups findings that share a root cause
Descriptions and remediation
Writes clear descriptions and remediation advice
Framework mapping
Maps findings to MITRE ATT&CK, CWE, OWASP Top 10, PCI DSS, ISO 27001 and NIST
Attack paths
Explains how findings could be combined
Proof of concept
Helps build and validate reproduction steps
Translation
Rewrites findings in other languages
Business impact
Explains each finding in business terms
Trends
Spots patterns across projects
Natural-language queries
Lets people ask questions about findings in plain language
Quality checks
Reviews writeups for accuracy and consistency
What you need
AttackForge Actions and Flows
A Microsoft Copilot Studio agent and agent flow
These AttackForge MCP tools, enabled for the user the agent connects as: Find Vulnerabilities, Find Writeups, Get Args Schema for Tool, Get Field Structure, Patch Writeup
1. Create the agent
In Copilot Studio, go to Agents > New agent.
Name the agent.
Choose a model. The example uses Claude Opus 4.5. We recommend a newer model.
Under Tools, connect the AttackForge MCP server. See Microsoft Copilot Studio.
Kepp Knowledge > Search all websites enabled.
Click Publish.








2. Create the agent flow that starts it
This example uses a Copilot Studio agent flow with an HTTP trigger. Any solution with an HTTP trigger works.
Create an agent flow, and choose Request > When an HTTP request is received.



Set Who can trigger the flow. Anyone is fine for testing; restrict it before you use it in production.
Set the Request Body JSON Schema:
Click +, and add Run an agent. Select the agent you created.



In Message, click Trigger function, select
Body, and click Add.
After the message, enter the prompt:
Turn off Request human assistance when unsure.
Click Publish.

Copy the HTTP URL from the trigger step. You'll need it for the Flow.

3. Create the Flow
In AttackForge, go to Flows > New > Create Flow.
Set:
Enabled: On
Trigger Type: Action
Restrict to: Project, Projects, Vulnerability, Vulnerabilities, Writeup, Writeups
Add an action:
Method: POST
URL: the HTTP URL you copied
Header:
Content-Type: application/jsonAdd the Request Script:
Add the Response Script. The agent flow replies
202when it accepts the request:
Click Create.
4. Create the Action
Go to Actions > All Actions > System Actions > New.
Set Entities to Project, Projects, Vulnerability, Vulnerabilities, Writeup and Writeups.
Under Flows, select the Flow you created.
Click Create.
5. Run it
The Action appears in the Actions menu. You can run it on:
a single project, or several projects
a single vulnerability, or several vulnerabilities
a single writeup, or several writeups
The agent updates each writeup's title, description, attack scenario, remediation recommendation and steps to reproduce.

Set up an OpenClaw agent
The penetration testing, retesting, executive summary and attack chain examples all use an OpenClaw agent, with a Microsoft Foundry model, started by a webhook from an AttackForge Flow. Set this up once, then add a hook for each workflow.

The example environment:
Server: OpenClaw runs on a Linux server.
Ingress: an NGINX reverse proxy. Allow only AttackForge's IP addresses, and require an auth key.
Hooks and transforms: OpenClaw hooks and transforms turn each Flow's webhook into instructions for the agent.
Gateway: the OpenClaw Gateway is running.
AttackForge MCP: the agent connects to the AttackForge MCP server, with only the tools its workflow needs (listed in each section below).
Model: Microsoft Foundry. Any model OpenClaw supports works.
Web search: configured.
Agent files:
AGENTS.md,HEARTBEAT.md,IDENTITY.md,SOUL.md,TOOLS.mdandUSER.mddefine the agent's role and behaviour.Testing tools: installed, for workflows that test or retest.
Security checklist
Restrict the hook endpoint by IP address, and require a bearer token.
Store the hostname, API key and hook names as Flow secrets, never in the script.
Give the agent's AttackForge user only the MCP tools its workflow needs.
Make sure every target is in scope and authorised before an agent tests it.
Review what the agent writes back before it reaches a client.
Flow secrets
Each OpenClaw Flow uses these secrets.
Secret
Used by
Value
openclaw_hostname
All four Flows
Your OpenClaw hostname
openclaw_api_key
All four Flows
The bearer token for OpenClaw hooks
openclaw_hackbot_trigger_name
Penetration testing
The hook name
openclaw_retest_trigger_name
Retesting
The hook name
openclaw_exec_summary_trigger_name
Executive summary
The hook name
openclaw_attack_chain_trigger_name
Attack chain analysis
The hook name
Each Flow sends a POST request to https://{{openclaw_hostname}}/hooks/{{hook_name}} with the header Content-Type: application/json.
Monitor an agent
Use the OpenClaw Gateway Control UI to see each session and follow the agent's progress.
Agentic penetration testing
An agent tests the project's scope, then records what it finds as vulnerabilities, with evidence, in AttackForge.

Benefit
What it means
Scale and coverage
Test more targets, more often
Continuous testing
Test whenever something changes, not just once a year
Faster first findings
Agents start finding issues within minutes
Multi-step attacks
Agents chain steps together as a tester would
Tool orchestration
Agents run and combine your testing tools
Consistency and auditability
Every step is logged and repeatable
Talent gap
Agents take on breadth work when testers are scarce
Realistic adversaries
Agents behave like a persistent attacker
Framework coverage
Agents can follow OWASP, PTES or your own methodology
Lower cost for repetitive work
People spend their time where expertise matters
What you need
AttackForge Actions and Flows
An OpenClaw agent, with a Microsoft Foundry model and your testing tools
These AttackForge MCP tools: Find Project, Find Project Scope, Create Writeup, Create Vulnerability, Patch Vulnerability, Get Args Schema for Tool, Get Field Structure, Count Vulnerabilities
1. Create the Flow
Go to Flows > New > Create Flow.
Set Enabled to On, Trigger Type to Action, and Restrict to Project.
Add an action named Trigger Hackbots and Start Hacking!, which sends a POST request to
https://{{openclaw_hostname}}/hooks/{{hook_name}}.Add the Request Script:
Add the Response Script. OpenClaw replies
200when it accepts the request:
Click Create.
2. Create the Action
Go to Actions > All Actions > System Actions > New.
Set Entities to Project, and select the Flow.
Click Create, and give users access.
Run the Action from the project's Actions menu. Vulnerabilities appear on the project as the agent finds, verifies and enriches them.

3. Collect testing requirements with a form
Add a custom form to the Action to shape the agent's instructions for each run. For example, a 👾 Launch AI Hackbots Action can ask for the assessment's requirements. The Flow receives the answers, checks and enriches them, and passes them to the agent.

4. Record the agent's test procedures as test cases
A test procedure is a step the agent performs, such as checking a login form for SQL injection. The agent can record each one as a project test case, with its notes and any linked vulnerabilities.
Benefit
What it gives you
Coverage
See what was tested, not just what was found
Reviewability
Testers can check each procedure
Durable state
Progress is saved in AttackForge, not only in the agent's session
Compliance evidence
Show coverage for PCI DSS, ISO 27001, SOC 2, OWASP WSTG and MASTG
Automation triggers
Test case changes can start other Flows
Measurability
Track progress with test case counts
Trends
Compare coverage across projects
Scope defence
Show exactly what was and wasn't tested
Reporting
Include test cases in reports
The agent records its steps in each test case's Execution Flows, and links any vulnerability it finds.
Give the agent these extra MCP tools: Create Abuse Case, Count Project Test Cases, Find Project Test Cases, Patch Project Test Case, Find Project Test Case Notes, Create Project Test Case Note, Patch Project Test Case Note, Find Vulnerabilities, Get Field Structure, Get Args Schema For Tool.


5. Drive the agent from your test cases
Instead of letting the agent decide what to test, give it the project's test cases to work through.
Advantage
Why
Scope containment
The agent tests only what's on the plan
Methodology guarantee
Your methodology is followed every time
A clear finish
The work is done when every test case has a status
Bounded cost
Model and compute use is predictable
No rabbit holes
The agent doesn't chase one lead forever
Division of labour
Assign some test cases to agents and others to people
Comparability
Results are comparable across projects
Consistent quality
Every test case is done the same way
Injection resistance
Instructions come from your test cases, not the target
Traceable deviation
Any departure from the plan is recorded
The agent works through each test case:
Read the test case's details.
Study its Execution Flows.
Plan the test.
Test.
Record the plan and outcome on the test case.
If it finds a vulnerability, create it and link it to the test case. A linked vulnerability fails the test case.
Set the status, such as Tested or Not Applicable.
Add notes.
Give the agent these MCP tools: Count Project Test Cases, Find Project Test Cases, Patch Project Test Case, Find Project Test Case Notes, Create Project Test Case Note, Patch Project Test Case Note, Find Vulnerabilities, Get Field Structure, Get Args Schema For Tool.

Agentic retesting
An agent retests the project's vulnerabilities, then reopens or closes each one and adds a remediation note with its evidence.

Benefit
What it means
Faster verification
Fixes are confirmed in hours, not weeks
Reproducible evidence
Each retest repeats the original steps and records the result
Parallel scale
Retest many vulnerabilities at once
Continuous verification
Retest whenever a fix is deployed
Lower cost
Routine retests no longer need a tester's time
Testers freed up
People focus on new testing
Better developer experience
Developers get answers quickly
What you need
AttackForge Actions and Flows
An OpenClaw agent, with a Microsoft Foundry model and your testing tools
These AttackForge MCP tools: Find Project, Find Vulnerabilities, Patch Vulnerability, Update Vulnerability Status, Create Remediation Note, Get Args Schema for Tool, Get Field Structure, Count Vulnerabilities
1. Create the Flow
Go to Flows > New > Create Flow.
Set Enabled to On, Trigger Type to Action, and Restrict to Project.
Add an action named Trigger Agent to Retest Project Vulnerabilities, which sends a POST request to
https://{{openclaw_hostname}}/hooks/{{hook_name}}.Add the Request Script:
Add the same Response Script as penetration testing.
Click Create.
2. Create the Action
Go to Actions > All Actions > System Actions > New.
Set Entities to Project, and select the Flow.
Click Create, and give users access.
Run the Action from the project's Actions menu. The agent retests the vulnerabilities you've asked it to, reopens or closes each one, and adds remediation notes. Follow its progress in the Control UI.


Agentic executive summary
An agent drafts the project's executive summary and saves it in the project's Reporting section.

Benefit
What it means
Faster drafts
A first draft is ready in minutes
Consistency
Every tester's summaries follow the same structure
Business language
Technical findings become business risk
Right audience
Tailor the summary for executives, boards or engineers
One story
The summary connects findings, rather than listing them
Localisation
Draft in the client's language
Senior time freed up
Leads review instead of writing from scratch
Consistent risk framing
Risk is described the same way across projects
What you need
AttackForge Actions and Flows
An OpenClaw agent, with a Microsoft Foundry model
These AttackForge MCP tools: Find Project, Find Vulnerabilities, Find Project Reporting Fields, Patch Project Reporting Fields, Get Args Schema for Tool, Get Field Structure
A prompt for the agent. See the Generate Pentest Executive Summary example.
1. Create the Flow
Go to Flows > New > Create Flow.
Set Enabled to On, Trigger Type to Action, and Restrict to Project.
Add an action named Trigger Agent To Create Exec Summary, which sends a POST request to
https://{{openclaw_hostname}}/hooks/{{hook_name}}.Add the Request Script:
Add the same Response Script as penetration testing.
Click Create.
2. Create the Action
Go to Actions > All Actions > System Actions > New.
Set Entities to Project, and select the Flow.
Click Create, and give users access.
Run the Action from the project's Actions menu. The agent writes the executive summary into the project's Reporting section. Follow its progress in the Control UI.


Agentic attack chain analysis
An agent works out how the project's findings could be chained into an attack, maps the chains to frameworks, and saves them to the project's Workspace.


Why attack chains matter
Benefit
What it means
Real impact
Shows what an attacker could actually achieve
Realism
Tests whether findings really combine
Break-the-chain remediation
Fix the link that stops the most chains
Framework mapping
Maps to MITRE ATT&CK and the Cyber Kill Chain
Systemic weaknesses
Reveals patterns behind individual findings
Why use an agent
Advantage
What it means
Speed to insight
Chains in minutes, not hours
Pattern recognition
Spots links between findings people miss
Consistent mapping
Frameworks are applied the same way each time
Executive translation
Chains are explained in business terms
Portfolio scale
Analyse many projects
Junior tester uplift
Less experienced testers learn from each chain
Reproducibility
Run the analysis again after fixes
Better prioritisation
Fix what breaks the most chains first
What you need
AttackForge Actions and Flows
An OpenClaw agent, with a Microsoft Foundry model
These AttackForge MCP tools: Find Project, Find Vulnerabilities, Get Args Schema for Tool, Get Field Structure
The Upload Workspace File API, so the agent can save its file to the project.
A skill for the agent. See the Interactive Attack Chain Explorer example.
1. Create the Flow
Go to Flows > New > Create Flow.
Set Enabled to On, Trigger Type to Action, and Restrict to Project.
Add an action named Trigger Agent To Create Attack Chain, which sends a POST request to
https://{{openclaw_hostname}}/hooks/{{hook_name}}.Add the Request Script:
Add the same Response Script as penetration testing.
Click Create.
2. Create the Action
Go to Actions > All Actions > System Actions > New.
Set Entities to Project, and select the Flow.
Click Create, and give users access.
Run the Action from the project's Actions menu. The agent analyses the project, builds the attack chains, saves them to a file and uploads it to the project's Workspace. Follow its progress in the Control UI.


Tips
Start with a read-only agent. Executive summary and attack chain analysis change little, so they're a safe first workflow. Add write tools later.
Give each agent its own AttackForge user. Grant only the MCP tools its workflow needs, so its access is easy to review and its changes are easy to trace.
Keep secrets in the Flow. Store hostnames, API keys and hook names as Flow secrets, never in scripts or prompts.
Lock down the trigger. Use "Anyone" only while testing. In production, restrict the HTTP trigger, allow only AttackForge's IP addresses, and require a bearer token.
Check the Flow's logs. The Response Script logs the full response when an agent fails to start.
Drive testing from test cases. Agents that work through your test cases stay in scope, follow your methodology and finish predictably.
Write detailed Execution Flows. The better the steps, the better the agent's testing.
Use a form for each run. A custom form on the Action lets users shape the agent's instructions without editing the prompt.
Review before you share. Treat everything an agent writes as a draft until a tester has checked it.
Reuse your prompts and skills. The prompt and skill examples work as agent instructions too.
FAQ
Do I have to use Copilot Studio or OpenClaw? No. Any agentic system that can receive an HTTP request and connect to AttackForge MCP works, including your own.
Which AI model should I use? Any model your agent platform supports. The examples use Claude Opus 4.5 in Copilot Studio, and Microsoft Foundry with OpenClaw.
Does an agent replace my testers? No. Agents cover breadth; testers cover depth, judgement and sign-off. Every example keeps a person in the loop.
How does the agent know which records to work on? The Flow sends the IDs of the project, vulnerabilities or writeups the user ran the Action on.
What can the agent change in AttackForge? Only what its MCP tools allow. Each section lists the tools that workflow needs.
The Action ran, but nothing happened. What should I check? Check the Flow's logs for the Response Script's error, then check that the agent's endpoint, secrets and MCP tools are set up. For OpenClaw, check the session in the Control UI.
Why does the enrichment Flow expect 202, and the others 200? Copilot Studio replies 202 Accepted when it queues the request. OpenClaw hooks reply 200. Match the Response Script to your platform.
Can users give the agent extra instructions? Yes. Add a custom form to the Action, and pass the answers to the agent through the Flow.
Is it safe to let an agent test a target? Only if the target is in scope and authorised, and the agent's environment is hardened. OpenClaw's defaults aren't secure.
Related pages
AI MCP and Skills: connect agents to AttackForge, and grant MCP tools.
Flows: send AttackForge data to your agent.
Actions: let users start an agent, with custom forms.
AFScript: the language for Flow request and response scripts.
Report automation: generate reports from the results.
OpenClaw documentation: set up, harden and monitor OpenClaw agents.
Microsoft Copilot Studio: build Copilot Studio agents and agent flows.
Last updated