> For the complete documentation index, see [llms.txt](https://support.attackforge.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://support.attackforge.com/app/automations-and-integrations/ai-agentic-workflows.md).

# 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](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills).

{% embed url="<https://youtu.be/G0lkH0_Ufms>" %}

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](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills#prompt-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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FXswxkSgLYEfTVxqsKCho%2Fai-agentic-workflows-at-a-glance.svg?alt=media&amp;token=8e96fac0-87de-452f-9c28-5d9ea23c4ebc" alt=""><figcaption></figcaption></figure>

## 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:

1. A user runs an [**Action**](https://support.attackforge.com/app/automations-and-integrations/actions) on a project, vulnerability or writeup.
2. The Action starts a [**Flow**](https://support.attackforge.com/app/automations-and-integrations/flows), which sends the record's IDs to your agent's HTTP endpoint.
3. The **agent** works on its own, using the **AttackForge MCP tools** you've given it.
4. The results appear in AttackForge: improved writeups, new vulnerabilities, updated test cases, retest outcomes, an executive summary or a workspace file.

{% hint style="info" %}
**Important:** You can use any agentic system, including one you build yourself. The examples use Microsoft Copilot Studio, and OpenClaw with Microsoft Foundry.
{% endhint %}

## 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FgT13WyWFQrBZMRCMv35a%2FAI%20Agentic%20Workflows.png?alt=media&amp;token=4da97ab8-8bd1-4ee0-8cc7-612fb97dfc0e" alt=""><figcaption></figcaption></figure>

### 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**

{% hint style="info" %}
**Important:** Any agentic system works, including your own.
{% endhint %}

### 1. Create the agent

1. In Copilot Studio, go to **Agents > New agent**.
2. Name the agent.
3. Choose a model. The example uses **Claude Opus 4.5**. We recommend a newer model.
4. Under **Tools**, connect the AttackForge MCP server. See [Microsoft Copilot Studio](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills#microsoft-copilot-studio-self-registration).
5. Kepp **Knowledge > Search all websites** enabled.
6. Click **Publish**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fj1Wu5rXXdM0GJNJDW9u8%2FScreenshot%202026-11-12%20at%2010.04.06%E2%80%AFam.png?alt=media&amp;token=e67c9de1-a838-40a8-b327-8f85ac39bd9d" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fz9pzLN2TKhcQMazrEUur%2FScreenshot%202026-11-12%20at%2010.04.12%E2%80%AFam.png?alt=media&amp;token=0a60f493-d35d-4e2c-9604-0c5dba40951d" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FL7XH1SIejU6HFmuXk2ck%2FScreenshot%202026-11-12%20at%2010.07.28%E2%80%AFam.png?alt=media&amp;token=d75bfbc4-34b8-4bd7-a7fa-be2c65bb62d1" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FtH0udR2jbhWRSJhOE09y%2FScreenshot%202026-11-12%20at%2010.07.36%E2%80%AFam.png?alt=media&amp;token=8e63a05e-521e-4c38-93d6-2a386f63f28d" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fpsjy5LR2trMaR34PwZtG%2FScreenshot%202026-11-12%20at%2010.10.08%E2%80%AFam.png?alt=media&amp;token=62a9014e-b267-4841-bb0c-3e4ef99966a7" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FP5PM3E4ufoRsoP6Z1MJn%2FScreenshot%202026-11-12%20at%2010.09.53%E2%80%AFam.png?alt=media&amp;token=0e7cc71a-5896-443e-8aaf-407c9cd83d40" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FDHKSUNqfVZe7n5u8IjxZ%2FScreenshot%202026-11-12%20at%2010.10.55%E2%80%AFam.png?alt=media&amp;token=4a564497-c95a-4cb6-8f12-8a8c16859172" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F7lnusF9NOAs4r4wEuLqE%2FScreenshot%202026-11-12%20at%2010.12.25%E2%80%AFam.png?alt=media&amp;token=7a21a0a2-2939-4f96-b222-52c2ada79197" alt=""><figcaption></figcaption></figure>

### 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.

1. Create an agent flow, and choose **Request > When an HTTP request is received**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FLV745vR7IstjQ09k5kkw%2FScreenshot%202026-11-12%20at%2010.13.37%E2%80%AFam.png?alt=media&amp;token=0d2d1ecb-a55c-4bab-8405-c7b7c81dbea8" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FxdT8WzH2EhfJuL4nCU3P%2FScreenshot%202026-11-12%20at%2010.13.43%E2%80%AFam.png?alt=media&amp;token=0b1870ba-6c3d-416c-89f7-f7706cca58a4" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fz5EQWwoLCPb1fOHZttJH%2FScreenshot%202026-11-12%20at%2010.15.54%E2%80%AFam.png?alt=media&amp;token=e8b935d9-c4c4-4bdb-8bfa-44fd987935bb" alt=""><figcaption></figcaption></figure>

2. Set **Who can trigger the flow**. **Anyone** is fine for testing; restrict it before you use it in production.
3. Set the **Request Body JSON Schema**:

```json
{
    "type": "object",
    "properties": {
        "project_ids": {
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "vulnerability_ids": {
            "type": "array",
            "items": {
                "type": "string"
            }
        },
        "writeup_ids": {
            "type": "array",
            "items": {
                "type": "string"
            }
        }
    },
    "additionalProperties": false
}
```

4. Click **+**, and add **Run an agent**. Select the agent you created.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fl4TJSFbCQZSKa6VlnZBv%2FScreenshot%202026-11-12%20at%2010.18.18%E2%80%AFam.png?alt=media&amp;token=eb6b4c56-d679-412d-be8e-2bb97fbf4f88" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FAf3pCW167HIQ9134a3wS%2FScreenshot%202026-11-12%20at%2010.23.56%E2%80%AFam.png?alt=media&amp;token=faa9130e-ffc7-42f6-8351-1670e355cfb7" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FU3WLiVu9ORPuwf74wNvx%2FScreenshot%202026-11-12%20at%2010.21.58%E2%80%AFam.png?alt=media&amp;token=e07c0dd9-d466-43de-b16a-d4e7229711ec" alt=""><figcaption></figcaption></figure>

5. In **Message**, click **Trigger function**, select `Body`, and click **Add**.

{% hint style="info" %}
**Important:** `Body` passes the request body (the IDs) to the agent with your prompt.
{% endhint %}

6. After the message, enter the prompt:

```
The goal is to improve the Writeups in AttackForge.

Improvements should focus on improving the following fields:
- Title
- Description
- Attack Scenario
- Remediation Recommendation
- Template Steps to Reproduce (POC)

You will recieve either of the following in the body:
- project_ids
- vulnerability_ids
- writeup_ids

If you receive a Writeup Id - improve that Writeup.

If you receive a Project Id - improve the Writeups for every Vulnerability on the Project.

If you receive a Vulnerability Id - improve the Writeup associated to that Vulnerability.

To improve the Writeup, you first need to identify the type of vulnerability discovered, then work out the relevant MITRE CWEs and MITRE CAPECs.

Patch the AttackForge Writeup to update the Title, Description, Attack Scenario, Remediation Recommendation and Template Steps to Reproduce (POC) using the data from MITRE CWE and MITRE CAPEC. Dont ask for confirmation - just do it.

Template Steps to Reproduce (POC) is a custom field.
```

7. Turn off **Request human assistance when unsure**.
8. Click **Publish**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FtFCcyfI2LNsGZtLrxJ9f%2FScreenshot%202026-11-12%20at%2010.26.31%E2%80%AFam.png?alt=media&amp;token=a82fbbbb-255c-4c6c-acb9-321d812c8aca" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FnVeFA9nOBjEYGhB0oi55%2FScreenshot%202026-11-12%20at%2010.27.01%E2%80%AFam.png?alt=media&amp;token=f921db9e-fd24-477b-b0a7-fb62a3549ee8" alt=""><figcaption></figcaption></figure>

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

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FdGu8tTuQlsOHn44mHVgV%2FScreenshot%202026-11-12%20at%2010.27.37%E2%80%AFam.png?alt=media&amp;token=aeedc976-1e1b-4b80-b31a-7f3a6f6518a5" alt=""><figcaption></figcaption></figure>

### 3. Create the Flow

1. In AttackForge, go to **Flows > New > Create Flow**.
2. Set:
3. **Enabled:** On
4. **Trigger Type:** Action
5. **Restrict to:** Project, Projects, Vulnerability, Vulnerabilities, Writeup, Writeups
6. Add an action:
7. **Method:** POST
8. **URL:** the HTTP URL you copied
9. **Header:** `Content-Type: application/json`
10. Add the **Request Script**:

```javascript
const body = {};

if (data.projects || data.project) {
  body.project_ids = [];
  
  if (data.projects && data.projects.length > 0) {
    for (let x = 0; x < data.projects.length; x++) {
      const project_id = data.projects[x];
      Array.push(body.project_ids, project_id);
    }
  }
  else if (data.project?.project_id) {
    Array.push(body.project_ids, data.project.project_id);
  }
}
else if (data.vulnerabilities || data.vulnerability) {
  body.vulnerability_ids = [];
  
  if (data.vulnerabilities && data.vulnerabilities.length > 0) {
    for (let x = 0; x < data.vulnerabilities.length; x++) {
      const vulnerability_id = data.vulnerabilities[x];
      Array.push(body.vulnerability_ids, vulnerability_id);
    }
  }
  else if (data.vulnerability?.vulnerability_id) {
    Array.push(body.vulnerability_ids, data.vulnerability.vulnerability_id);
  }
}
else if (data.writeups || data.writeup) {
  body.writeup_ids = [];
  
  if (data.writeups && data.writeups.length > 0) {
    for (let x = 0; x < data.writeups.length; x++) {
      const writeup_id = data.writeups[x];
      Array.push(body.writeup_ids, writeup_id);
    }
  }
  else if (data.writeup?.id) {
    Array.push(body.writeup_ids, data.writeup.id);
  }
}

if (!body.project_ids && !body.vulnerability_ids && !body.writeup_ids) {
  return {
    decision: {
      status: 'abort',
      message: 'body is missing project_ids and vulnerability_ids and writeup_ids. Exiting.',
    }
  };
}
if (body.project_ids && Array.length(body.project_ids) === 0) {
  return {
    decision: {
      status: 'abort',
      message: 'body has no project_ids. Exiting.',
    }
  };
}
if (body.vulnerability_ids && Array.length(body.vulnerability_ids) === 0) {
  return {
    decision: {
      status: 'abort',
      message: 'body has no vulnerability_ids. Exiting.',
    }
  };
}
if (body.writeup_ids && Array.length(body.writeup_ids) === 0) {
  return {
    decision: {
      status: 'abort',
      message: 'body has no writeup_ids. Exiting.',
    }
  };
}

return {
  decision: {
    status: 'continue',
    message: 'Trigger agent to improve Writeups',
  },
  request: {
    body: body
  }
};
```

5. Add the **Response Script**. The agent flow replies `202` when it accepts the request:

```javascript
if (response?.statusCode === 202) {
  return {
    decision: {
      status: 'finish',
      message: 'Agent successfully triggered!',
    }
  };
}
else {
  Logger.error(JSON.stringify(response));
  return {
    decision: {
      status: 'abort',
      message: 'Error triggering Agent',
    }
  };
}
```

6. Click **Create**.

### 4. Create the Action

1. Go to **Actions > All Actions > System Actions > New**.
2. Set **Entities** to Project, Projects, Vulnerability, Vulnerabilities, Writeup and Writeups.
3. Under **Flows**, select the Flow you created.
4. Click **Create**.

{% hint style="info" %}
**Reminder:** Give other users access to the Action to roll it out.
{% endhint %}

### 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FI4EuVwNw1hZ7FbASRn2R%2FScreenshot%202026-11-12%20at%2010.30.31%E2%80%AFam.png?alt=media&amp;token=48444002-37c5-4a0d-a2fd-7017c98d244c" alt=""><figcaption></figcaption></figure>

## Set up an OpenClaw agent

The penetration testing, retesting, executive summary and attack chain examples all use an [OpenClaw](https://docs.openclaw.ai/) 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F6fSapY9LUORowFE9tjgr%2FAI%20Agentic%20Workflows%20(2).png?alt=media&amp;token=d85181fb-7100-4e31-89f5-40cee420334a" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
**Important:** OpenClaw's default settings aren't secure. Harden the environment before you connect it to AttackForge or to any target.
{% endhint %}

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](https://docs.openclaw.ai/) 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.md` and `USER.md` define 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](https://docs.openclaw.ai/web/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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F0XOPEjQSEtG3K98KQjaa%2FAI%20Agentic%20Workflows.png?alt=media&amp;token=21b55735-9321-4cb1-a444-f53194e9a378" alt=""><figcaption></figcaption></figure>

| 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       |

{% hint style="info" %}
**Important:** Agents extend your testers; they don't replace them. AI agents cover breadth; humans cover depth.
{% endhint %}

### 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

1. Go to **Flows > New > Create Flow**.
2. Set **Enabled** to On, **Trigger Type** to Action, and **Restrict to** Project.
3. Add an action named **Trigger Hackbots and Start Hacking!**, which sends a POST request to `https://{{openclaw_hostname}}/hooks/{{hook_name}}`.
4. Add the **Request Script**:

```javascript
const body = {};

if (data.project?.project_id) {
  body.project_id = data.project.project_id;
}

if (!body.project_id) {
  return {
    decision: {
      status: 'abort',
      message: 'body is missing project_id. Exiting.',
    }
  };
}

return {
  decision: {
    status: 'continue',
     message: 'Trigger agent to start hacking',
  },
  request: {
    url: 'https://' + secrets.openclaw_hostname + '/hooks/' + secrets.openclaw_hackbot_trigger_name,
    headers: {
      'Authorization': 'Bearer ' + secrets.openclaw_api_key
    },
    body: body
  }
};
```

5. Add the **Response Script**. OpenClaw replies `200` when it accepts the request:

```javascript
if (response?.statusCode === 200) {
  return {
    decision: {
      status: 'finish',
      message: 'Agent successfully triggered!',
    }
  };
}
else {
  Logger.error(JSON.stringify(response));
  return {
    decision: {
      status: 'abort',
      message: 'Error triggering Agent',
    }
  };
}
```

6. Click **Create**.

### 2. Create the Action

1. Go to **Actions > All Actions > System Actions > New**.
2. Set **Entities** to Project, and select the Flow.
3. 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F91p4Jol290bXxd5n0XEg%2FScreenshot%202026-11-12%20at%2010.33.23%E2%80%AFam.png?alt=media&amp;token=596ca6ee-93cc-40b1-977e-68724dd0acab" alt=""><figcaption></figcaption></figure>

### 3. Collect testing requirements with a form

Add a [custom form](https://support.attackforge.com/app/automations-and-integrations/actions#custom-forms-on-actions) 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FGqK3ntZ1mroygbhAeb0n%2FScreenshot%202026-11-12%20at%2010.33.50%E2%80%AFam.png?alt=media&amp;token=4897452c-2888-425f-a494-fd8aeb12e506" alt=""><figcaption></figcaption></figure>

### 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**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FKJOUgHsiJPONBOi94YZN%2FScreenshot%202026-11-12%20at%2010.35.45%E2%80%AFam.png?alt=media&amp;token=7b0e217f-3352-47d9-8545-550d5e3b77ec" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FONmT2PvwHMn8vxFEIu12%2Fimage.png?alt=media&amp;token=a7463bfe-8d57-4c4e-bbb7-1271e2bbc551" alt=""><figcaption></figcaption></figure>

### 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:

1. Read the test case's details.
2. Study its **Execution Flows**.
3. Plan the test.
4. Test.
5. Record the plan and outcome on the test case.
6. If it finds a vulnerability, create it and link it to the test case. A linked vulnerability fails the test case.
7. Set the status, such as Tested or Not Applicable.
8. Add notes.

{% hint style="info" %}
**Tip:** Detailed Execution Flows give better results. You can use AI to write a first draft of them.
{% endhint %}

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**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FM4QskbXTqWHtaY12Wk9K%2FScreenshot%202026-11-12%20at%2010.37.43%E2%80%AFam.png?alt=media&amp;token=5d7afbe6-0107-465f-a138-504c8e247e9d" alt=""><figcaption></figcaption></figure>

## Agentic retesting

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

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2F40AwHWQfzgyu8z5xLP4c%2FAI%20Agentic%20Retest.png?alt=media&amp;token=08f64971-eaa8-482b-bb34-8d3899cf862a" alt=""><figcaption></figcaption></figure>

| 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                                |

{% hint style="info" %}
**Important:** Agents are good at repeating a known exploit, but less reliable at judging whether a different fix, such as a WAF rule instead of a code change, really closes the weakness. Keep a person in the loop to make that call.
{% endhint %}

### 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

1. Go to **Flows > New > Create Flow**.
2. Set **Enabled** to On, **Trigger Type** to Action, and **Restrict to** Project.
3. Add an action named **Trigger Agent to Retest Project Vulnerabilities**, which sends a POST request to `https://{{openclaw_hostname}}/hooks/{{hook_name}}`.
4. Add the **Request Script**:

```javascript
const body = {};

if (data.project?.project_id) {
  body.project_id = data.project.project_id;
}

if (!body.project_id) {
  return {
    decision: {
      status: 'abort',
      message: 'body is missing project_id. Exiting.',
    }
  };
}

return {
  decision: {
    status: 'continue',
     message: 'Trigger agent to start retesting',
  },
  request: {
    url: 'https://' + secrets.openclaw_hostname + '/hooks/' + secrets.openclaw_retest_trigger_name,
    headers: {
      'Authorization': 'Bearer ' + secrets.openclaw_api_key
    },
    body: body
  }
};
```

5. Add the same **Response Script** as penetration testing.
6. Click **Create**.

### 2. Create the Action

1. Go to **Actions > All Actions > System Actions > New**.
2. Set **Entities** to Project, and select the Flow.
3. 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fi2uxoHqtP0fxR4NjDQ7X%2FScreenshot%202026-11-12%20at%2010.39.24%E2%80%AFam.png?alt=media&amp;token=3463517f-e7e4-4a73-884e-2e2a5fdea973" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FOc67BWN95uEyZjewZvg8%2Fimage.png?alt=media&amp;token=ebe4748c-202c-4990-897f-e75c006823ab" alt=""><figcaption></figcaption></figure>

## Agentic executive summary

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

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fh6VdFAqJyVzDVg21Hxp8%2FAI%20Exec%20Summary.png?alt=media&amp;token=cf61b2c6-e4b7-4937-82b6-521b626d4391" alt=""><figcaption></figcaption></figure>

| 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          |

{% hint style="info" %}
**Important:** A person must review and sign off every AI draft. Treat the AI as the first draft, and the tester as the editor.
{% endhint %}

### 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](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills#generate-pentest-executive-summary) example.

### 1. Create the Flow

1. Go to **Flows > New > Create Flow**.
2. Set **Enabled** to On, **Trigger Type** to Action, and **Restrict to** Project.
3. Add an action named **Trigger Agent To Create Exec Summary**, which sends a POST request to `https://{{openclaw_hostname}}/hooks/{{hook_name}}`.
4. Add the **Request Script**:

```javascript
const body = {};

if (data.project?.project_id) {
  body.project_id = data.project.project_id;
}

if (!body.project_id) {
  return {
    decision: {
      status: 'abort',
      message: 'body is missing project_id. Exiting.',
    }
  };
}

return {
  decision: {
    status: 'continue',
     message: 'Trigger agent to create executive summary for project',
  },
  request: {
    url: 'https://' + secrets.openclaw_hostname + '/hooks/' + secrets.openclaw_exec_summary_trigger_name,
    headers: {
      'Authorization': 'Bearer ' + secrets.openclaw_api_key
    },
    body: body
  }
};
```

5. Add the same **Response Script** as penetration testing.
6. Click **Create**.

### 2. Create the Action

1. Go to **Actions > All Actions > System Actions > New**.
2. Set **Entities** to Project, and select the Flow.
3. 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FKumImt5zcZ1KsK0yu0Z1%2FScreenshot%202026-11-12%20at%2010.40.40%E2%80%AFam.png?alt=media&amp;token=a253bc3f-0821-492a-b151-bc224aa53fb7" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FhWiaaObsg9tpmDDGd1sk%2Fimage.png?alt=media&amp;token=30b91480-e365-45bd-b9ca-20f4c81fa1b8" alt=""><figcaption></figcaption></figure>

## 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**.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2Fd1rinHVisPLYwpsWHMms%2FAI%20Attack%20Chain.png?alt=media&amp;token=418b1088-41e6-41b7-a1d2-db3988791333" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FHbSsQxLcaSXHmRbokO1K%2Fimage.png?alt=media&amp;token=932ffdc6-54a6-4717-b607-44a78079bdb2" alt=""><figcaption></figcaption></figure>

### 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          |

{% hint style="info" %}
**Important:** A tester must check each chain the agent proposes: that it's really feasible, and that it doesn't include invented techniques.
{% endhint %}

### 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](https://docs.attackforge.com/rest-api/methods/uploadWorkspaceFile) API, so the agent can save its file to the project.
* A skill for the agent. See the [Interactive Attack Chain Explorer](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills#interactive-attack-chain-explorer) example.

### 1. Create the Flow

1. Go to **Flows > New > Create Flow**.
2. Set **Enabled** to On, **Trigger Type** to Action, and **Restrict to** Project.
3. Add an action named **Trigger Agent To Create Attack Chain**, which sends a POST request to `https://{{openclaw_hostname}}/hooks/{{hook_name}}`.
4. Add the **Request Script**:

```javascript
const body = {};

if (data.project?.project_id) {
  body.project_id = data.project.project_id;
}

if (!body.project_id) {
  return {
    decision: {
      status: 'abort',
      message: 'body is missing project_id. Exiting.',
    }
  };
}

return {
  decision: {
    status: 'continue',
     message: 'Trigger agent to start attack chain analysis',
  },
  request: {
    url: 'https://' + secrets.openclaw_hostname + '/hooks/' + secrets.openclaw_attack_chain_trigger_name,
    headers: {
      'Authorization': 'Bearer ' + secrets.openclaw_api_key
    },
    body: body
  }
};
```

5. Add the same **Response Script** as penetration testing.
6. Click **Create**.

### 2. Create the Action

1. Go to **Actions > All Actions > System Actions > New**.
2. Set **Entities** to Project, and select the Flow.
3. 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.

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FQkpuoOfXV62yuasqExJ6%2FScreenshot%202026-11-12%20at%209.52.54%E2%80%AFam.png?alt=media&amp;token=5eaa94b4-c5e9-4181-b701-e452b78a76c9" alt=""><figcaption></figcaption></figure>

<figure><img src="https://372186556-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-M8s1QY2Q6YTHB4a6DMu%2Fuploads%2FLFDDpwBR4jB0wSYSwHL3%2Fimage.png?alt=media&amp;token=20ad01e6-78ff-4d51-922f-8cd6c8535244" alt=""><figcaption></figcaption></figure>

## 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](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills#prompt-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](https://support.attackforge.com/app/automations-and-integrations/ai-mcp-and-skills): connect agents to AttackForge, and grant MCP tools.
* [Flows](https://support.attackforge.com/app/automations-and-integrations/flows): send AttackForge data to your agent.
* [Actions](https://support.attackforge.com/app/automations-and-integrations/actions): let users start an agent, with custom forms.
* [AFScript](https://support.attackforge.com/app/automations-and-integrations/afscript): the language for Flow request and response scripts.
* [Report automation](https://support.attackforge.com/app/automations-and-integrations/report-automation): generate reports from the results.
* [OpenClaw documentation](https://docs.openclaw.ai/): set up, harden and monitor OpenClaw agents.
* [Microsoft Copilot Studio](https://learn.microsoft.com/en-us/microsoft-copilot-studio/): build Copilot Studio agents and agent flows.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://support.attackforge.com/app/automations-and-integrations/ai-agentic-workflows.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
