> For the complete documentation index, see [llms.txt](https://www.quillaudits.com/quillshield/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.quillaudits.com/quillshield/guides/guides/workflows.md).

# Workflows

What a workflow is, the kinds you can run, what's inside one, how results flow to findings, prices, roles and where everything lives.

A **workflow** is the plan an audit follows: what the AI agents look for, in what order, and what they report. Every audit runs exactly one workflow. Unless you choose another one, that's the **QuillShield Audit Agent**, QuillShield's full audit pipeline. You can also run an official workflow that goes deep on one kind of bug, a workflow another team published to the **Marketplace**, or one you build yourself in Workflow Studio by describing in plain words what the audit should look for. Whichever you choose, the price is the same: it depends on how much code you audit, not on the workflow.

<figure><img src="https://1210220531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRJce4WSdmcKoGJS4NwYy%2Fuploads%2Fw36j2ZkcjVkZXbxGoSC1%2Fworkflows-page.jpg?alt=media" alt="The Workflows page on the My library tab: the Describe your own workflow card with example chips and a Build it button, and workflow cards below it"><figcaption><p>The Workflows page: <strong>My library</strong>, the <strong>Marketplace</strong> tab, and the “Describe your own workflow” card.</p></figcaption></figure>

{% hint style="info" %}
**Workflows** is in the sidebar, between **Audits** and **CI/CD Checks**. If your sidebar has no Workflows entry, workflows aren't turned on for your workspace yet. Ask the QuillAudits team through **Support**.
{% endhint %}

## What a workflow is

A workflow splits an audit into **stages** that run one after another:

1. **The first stage looks around.** Its agents read your in-scope Solidity files and list things worth checking, for example every function an outsider can call that moves funds.
2. **Later stages dig in.** A later stage runs once for each item on that list, so every item gets its own **agent run**, and those runs happen side by side.
3. **The last stage reports findings.** Each finding has a title, a severity, a file and line, what's wrong and the impact.
4. **Then the findings are tidied up.** QuillShield can merge duplicates, hide low ratings, re-check severities with your rules, and run **follow-ups** on each finding, such as writing a Foundry proof-of-concept test.

Everything in a workflow is readable text. You can open any workflow built from stages (every one except the QuillShield Audit Agent) and see the exact instructions each agent gets, what each stage hands to the next, and what happens after the findings are in. A workflow contains none of your code: agents read your code only when an audit runs.

Workflows are versioned. In the app's words: “Saving makes a version that can't be changed later. Audits always run the exact version they were started with.”

### When to use something other than the default

The **QuillShield Audit Agent** is QuillShield's complete audit and a good first audit for a new codebase. Reach for another workflow when:

* **You want depth on one risk.** Official workflows focus on attack paths from public entry points, access control, oracle and price manipulation, or accounting invariants.
* **Your protocol has specifics.** Your own workflow can ask questions before each audit (such as which contracts matter most) and carry reference notes about trusted roles and behavior that is safe on purpose.
* **You want proof for serious bugs.** A follow-up can write and run a Foundry test for findings rated high and above (up to 30 per audit).
* **You want a repeatable house method.** Your team can run the same method on every release and improve it version by version. Each audit runs, and records, the exact version it was quoted with.
* **You want to share a method.** You can publish your workflow to the Marketplace for other organizations.

{% hint style="warning" %}
Audits that run a custom workflow (any workflow other than the QuillShield Audit Agent, official ones included) always run fresh: they never reuse an earlier report, they don't become the baseline for [CI/CD Checks](https://www.quillaudits.com/quillshield/guides/guides/ci-cd-checks), and they don't add the free CI/CD light scans that a full audit gives. Run the **QuillShield Audit Agent** when you need a CI/CD baseline.
{% endhint %}

## The kinds of workflows

| Kind                        | Made by                                                            | Can you change it?                                                                                                   | Where you find it                                                                              |
| --------------------------- | ------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| **QuillShield Audit Agent** | QuillShield                                                        | No. Its **How it works** tab says: “This is QuillShield's full audit pipeline. It isn't built from editable stages.” | **My library**, with the **Official** badge, plus **Default** until you choose another default |
| **Official workflows**      | QuillShield                                                        | Not directly. **Copy and edit** makes an editable copy for your organization.                                        | **My library** and the **Marketplace** tab, with the **Official** badge                        |
| **Marketplace workflows**   | Other organizations, reviewed by QuillShield before they're listed | Not directly. **Copy and edit** makes your own copy.                                                                 | **Marketplace** tab. **Add to library** puts one in **My library**.                            |
| **Your own workflows**      | Your organization's owners and admins                              | Yes, in Workflow Studio (**Edit in studio**)                                                                         | **My library**, with the **Yours** badge (or its marketplace status)                           |

You can build your own workflow in five ways: describe it in plain words, answer three quick questions, start from an example, start from scratch (a simple two-stage workflow), or import a workflow file. You can also copy an existing workflow with **Copy and edit**. See [Create a workflow](https://www.quillaudits.com/quillshield/guides/guides/workflows/create-a-workflow.md).

### The official workflows

| Workflow                          | What it looks for                                                                                                                 | How it runs                                                                                              | Extras                                                                     | Size in a typical audit             |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ----------------------------------- |
| **QuillShield Audit Agent**       | “The complete QuillShield audit: build checks, protocol mapping, multi-agent review, PoC verification and a deduplicated report.” | Full QuillShield pipeline                                                                                | Verified proof-of-concept exploits                                         | Not built from stages               |
| **Entry-point attack paths**      | “Maps every externally reachable entry point, traces its execution paths, and verifies each path for a concrete exploit.”         | Map entry points → Trace execution paths (for each entry point) → Verify one path (reports findings)     | Severity check; Foundry proof of concept for findings rated high and above | About 21 agent runs (work limit 90) |
| **Access-control consistency**    | “Inventories every guarded function, compares guards between functions that touch the same state, and confirms missing checks.”   | Inventory guarded functions → Compare guards (all results together) → Confirm the gap (reports findings) | None                                                                       | About 6 agent runs (work limit 40)  |
| **Oracle and price manipulation** | “Finds every price, rate and share-price read and checks each for staleness, manipulation and decimal errors.”                    | Find price reads → Assess manipulation (reports findings)                                                | Foundry proof of concept for findings rated high and above                 | About 5 agent runs (work limit 50)  |
| **Accounting invariants**         | “Infers the protocol's accounting invariants and checks every function that writes the involved state for a violation.”           | Infer invariants → Find violations (reports findings)                                                    | None                                                                       | About 5 agent runs (work limit 40)  |

The sizes are the app's own estimate, which assumes about 4 results per list. A real audit can use more or fewer runs, never more than the work limit. Follow-up runs come on top of that and aren't counted against the work limit.

### Badges on workflow cards

| Badge                        | Meaning                                                                                                                                                                                                             |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Default**                  | Audits use this workflow unless someone picks another one in the audit's **Workflow** step.                                                                                                                         |
| **Official**                 | Made and maintained by QuillShield.                                                                                                                                                                                 |
| **Yours**                    | Your organization owns it and hasn't published it.                                                                                                                                                                  |
| **In review**                | You published your workflow and QuillShield is reviewing it before listing it. A workflow that's already listed keeps **In marketplace** while a newer version is reviewed; its page says “Version N is in review.” |
| **In marketplace**           | Your workflow is listed in the Marketplace for other organizations.                                                                                                                                                 |
| **Changes requested**        | QuillShield's review didn't approve your workflow, so it isn't listed. The workflow page shows the review note.                                                                                                     |
| **Removed from marketplace** | QuillShield took your workflow off the Marketplace. The workflow page shows the note.                                                                                                                               |
| **In library**               | Another organization's workflow that you added to your library.                                                                                                                                                     |
| **Unavailable**              | Another organization's workflow in your library that QuillShield removed from the Marketplace. It can't run.                                                                                                        |

## What's inside a workflow

The studio, the **How it works** tab of a workflow's page and the **How it works** sheet in the audit wizard show a workflow as a **map** titled “How your workflow runs”, read from top to bottom in the order things happen.

| Part                          | What it is                                                                                                                                                                                                          | Example (from **Entry-point attack paths**)                                                                                                                   |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **At a glance**               | A summary card: **Looks for**, **How it runs**, **You get**, **Size** and **Your code**, plus **Walk through a typical audit**.                                                                                     | “About 21 agent runs in a typical audit (work limit 90).”                                                                                                     |
| **Before each audit**         | Optional questions the person starting an audit answers before checkout. Agents can use the answers. Up to 10.                                                                                                      | “No questions. The audit starts right after checkout.”                                                                                                        |
| **Stage**                     | One numbered round of work. Stage 1 runs once over your in-scope files. Each later stage runs once for each result of the stage above, or once with all of them together. The last stage reports findings. Up to 6. | Stage 1, **Map entry points**: “Runs once over your in-scope files”                                                                                           |
| **Agent**                     | One AI worker inside a stage, with a name and its own **instructions**. Several agents in one stage run side by side. Up to 6 per stage and 24 per workflow.                                                        | **Verify one path**                                                                                                                                           |
| **Instructions**              | What one agent is told to do, in plain text. **Placeholders** (shown as pills, such as **in-scope files** or **entry point · from stage 1**) are filled in with real values when the audit runs.                    | “Decide whether this execution path is exploitable.”                                                                                                          |
| **Passes on**                 | The details each result of a stage carries to the next stage.                                                                                                                                                       | entry point, contract file, why risky                                                                                                                         |
| **Finding details**           | What every finding of the last stage includes. Title, severity, file, line, what's wrong and impact are always there; you can add more.                                                                             | “Each finding includes: title · severity · file · line · what's wrong · impact · fix suggestion · attack path · example malicious input · who can exploit it” |
| **After the findings are in** | What happens once all stages are done, in this order: **Merge duplicate findings**, **Hide findings rated below**, **Severity check**, then **Follow-ups for each finding (up to 30 findings)**.                    | Severity check on; “Foundry proof of concept” for findings rated high and above                                                                               |
| **More options**              | **Reference notes for every agent** (Markdown notes every agent can read), **Depth and limits** (AI model, thinking effort, work limit, passes per agent) and **Name, summary and listing details**.                | “Depth and limits · Custom · Balanced model · work limit 90”                                                                                                  |

<figure><img src="https://1210220531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRJce4WSdmcKoGJS4NwYy%2Fuploads%2FDYrEz8C6TwyVZqGf4mwU%2Fstage-card.jpg?alt=media" alt="A stage card titled 2 agents side by side, with two agent cards whose instructions show placeholder pills such as target · from stage 1, and a footer listing what each finding includes"><figcaption><p>A stage with two agents side by side. Pills such as “target · from stage 1” show what each agent reads, and the footer lists what every finding includes.</p></figcaption></figure>

Every part also has a technical name (level, step, prompt, enricher…) used in downloaded workflow files, the API and the app's **Show technical details** view. The [Glossary](https://www.quillaudits.com/quillshield/guides/guides/workflows/glossary.md) lists both.

## How results flow from stage to stage

Each stage hands its results down to the next one, and the last stage's results become findings. Here is the flow for a three-stage workflow, with the run counts the app assumes for a typical audit (about 4 results per list):

```
 your in-scope Solidity files
             │
             ▼
 Stage 1 ─ runs once                          1 run
           lists 4 entry points
             │  For each entry point ↓
             ▼
 Stage 2 ─ runs once per entry point          4 runs
           lists 4 paths for each = 16 paths
             │  For each path ↓
             ▼
 Stage 3 ─ runs once per path                16 runs
 (last)    returns a finding, or nothing
             │
             ▼
 After the findings are in
   1. merge duplicate findings
   2. hide findings rated below your cut-off
   3. severity check (re-rate with your rules)
   4. follow-ups for each finding (e.g. a PoC)
             │
             ▼
 findings and report on the audit page
```

The words on the map tell you how each hand-off works:

* **For each entry point ↓** (or “For each … ↓” with whatever the stage above lists) means the next stage runs **once for each** result of the stage above. The app calls a result by the detail that names it, so a stage that passes on an entry point gives you “for each entry point”.
* **All results together ↓** means the next stage runs **once with everything** the stage above found, to compare or group the results. Its agents get the whole list through the **all results from stage N** placeholder.
* **Each run can return: Several results (up to 25)** lets one run return a list. **At most one result** means each run returns one result or nothing. The last stage of **Entry-point attack paths** returns at most one finding per path.
* **Takes results from** appears when the stage above has two or more agents: an agent can take results from just one of them instead of all of them.
* **Agents read details from every stage above them.** A result remembers where it came from, so stage 3 can use the entry point from stage 1 and the path from stage 2. A stage that looks at all results together starts a fresh chain: later stages see what it passes on, not the details from before it.
* **Every agent run sees the list of in-scope files**, even when its instructions don't mention them.

An **agent run** is one agent working once on one input. The **work limit** caps how many agent runs the stages may use in one audit (from 1 to 150). QuillShield keeps at least one run in reserve for every agent in a later stage, so a very long list in stage 1 can't stop the last stage from running. When an audit would need more runs than the limit, later results are skipped. Follow-ups run after the stages and aren't counted against the work limit. None of this changes the price.

## Worked example: Entry-point attack paths

**Entry-point attack paths** is an official workflow for DeFi protocols. Its description starts: “A general-purpose workflow for DeFi protocols.” It answers one question: can an untrusted caller reach a function, follow a path through it and walk away with something? Open it from **Workflows → My library**.

<figure><img src="https://1210220531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRJce4WSdmcKoGJS4NwYy%2Fuploads%2FYE1gWAkdImdPcYG46hAS%2Fworkflow-page.jpg?alt=media" alt="The Entry-point attack paths workflow page with the Official badge, the buttons Use in an audit, Copy and edit, Make default and Download, stats for Version, Stages · agents, Agent runs, Used in and Rating, and the At a glance card on the Overview tab"><figcaption><p>The workflow page. The <strong>Overview</strong> tab starts with <strong>At a glance</strong>; <strong>How it works</strong> shows the full map.</p></figcaption></figure>

The stats row shows the current **Version**, **Stages · agents** 3 · 3 (three stages, one agent each) and **Agent runs** \~21, max 90. Here is what happens when an audit runs it, in order:

{% stepper %}
{% step %}

### Before each audit

“No questions. The audit starts right after checkout.” The agents work from your in-scope files and the project name.
{% endstep %}

{% step %}

### Stage 1 · Map entry points

“Runs once over your in-scope files”, on the **Fast** AI model (“Quick model for mapping and triage stages.”).

The agent maps the attack surface. It lists every external or public function an untrusted caller can reach that moves value, changes balances or accounting, changes ownership or configuration, or calls other contracts. It skips view and pure functions, and skips functions restricted to admin roles unless anyone can obtain that role. It returns at most 25 entry points, the most valuable first.

Each result passes on three details:

* **entry point**: the function, written as `Contract.function(argument types)`
* **contract file**: the file that defines it
* **why risky**: one or two sentences on what an attacker can influence
  {% endstep %}

{% step %}

### Stage 2 · Trace execution paths

“Runs once for each entry point from stage 1 · about 4 agent runs”, on the workflow's default **Balanced** model.

Each run gets one entry point (its **entry point**, **contract file** and **why risky**). The agent reads the function and everything it calls, and lists the materially different execution paths: validation branches, external calls, callbacks, token transfers and state changes. It returns at most 6 paths, and nothing at all if no path can be influenced by an untrusted caller.

Each path passes on:

* **path**: the ordered calls and state changes, with file:line references
* **preconditions**: what the caller must control or arrange first
  {% endstep %}

{% step %}

### Stage 3 · Verify one path

“Runs once for each path from stage 2 · about 16 agent runs”, on the **Deep** model (“Strongest platform model with extended reasoning for verification.”). The card carries the **Reports findings** badge.

Each run gets one path and its preconditions, plus the entry point and contract file the path came from. The agent checks modifiers, access control, reentrancy protection, rounding, price and balance assumptions, and invariants along the path. It reports a finding only if it can describe a concrete sequence of transactions an attacker can execute and what they gain, citing the exact file and line of the root cause. It rates severity with this guide, written into its instructions:

| Severity | Meaning in the instructions                                                                          |
| -------- | ---------------------------------------------------------------------------------------------------- |
| critical | Direct theft or permanent loss of user funds, or full protocol takeover, by an unprivileged attacker |
| high     | Loss of funds under realistic conditions, or permanent freezing of funds                             |
| medium   | Limited loss, temporary freezing, or griefing that costs the attacker little                         |
| low      | Minor issues with no direct loss                                                                     |
| info     | Best-practice notes                                                                                  |

“If the path is safe, return no result.” Each run returns at most one finding, and “Each finding includes: title · severity · file · line · what's wrong · impact · fix suggestion · attack path · example malicious input · who can exploit it”.
{% endstep %}

{% step %}

### After the findings are in

In this order:

1. **Merge duplicate findings** is on, so two paths that lead to the same bug become one finding.
2. **Hide findings rated below** is set to **Low**, so info-level notes are dropped.
3. The **Severity check** is on, with these rules: “Rank by realistic loss to users or the protocol. Unprivileged attacks beat privileged ones. Downgrade findings that need a malicious admin, an unrealistic market state, or that only affect the attacker.”
4. The follow-up **Foundry proof of concept** runs for up to 30 findings rated high and above. It writes a Foundry test at `test/QuillShieldPoc.t.sol`, runs it with `forge test`, and fixes compile errors until the test runs, without touching your production contracts. It works in a throwaway copy of your code. QuillShield then re-runs the test itself in a clean copy, and the proof of concept counts as passed only if that run passes.
   {% endstep %}
   {% endstepper %}

**Depth and limits** shows “Custom · Balanced model · work limit 90”: Balanced as the default model, **Medium** thinking effort, one pass per agent, and a work limit of 90. It reads Custom because a work limit of 90 doesn't match the Quick (30), Standard (60) or Deep (150) presets.

**Walk through a typical audit** on the At a glance card puts it all in one paragraph: “Assuming about 4 results per list: stage 1 runs once and lists entry points; stage 2 runs once for each (about 4 runs) and lists paths; stage 3 checks each path (about 16 runs) and reports findings. Then duplicates are merged, findings rated below low are hidden, the severity check re-rates them with your rules, and up to 30 findings rated high and above get “Foundry proof of concept”. About 21 agent runs for the stages (work limit 90), plus up to 30 follow-up runs, which the work limit doesn't cover.”

Lists can be much longer than the typical 4. If stage 1 listed its maximum of 25 entry points and stage 2 found 6 paths for each (the most its instructions allow), the stages would need 176 runs: 1 + 25 + 150. The work limit of 90 caps that: stage 1 and stage 2 would use 26 runs, stage 3 would check 64 of the 150 paths, and the other 86 would go unchecked. The run kept in reserve for stage 3 makes sure it always gets to run.

<figure><img src="https://1210220531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRJce4WSdmcKoGJS4NwYy%2Fuploads%2FBjMNkQmdsd1jrjA5kc6P%2Fworkflow-how-it-works.jpg?alt=media" alt="The How it works tab of Entry-point attack paths: the note Want to change it? Use Copy and edit, the How your workflow runs heading, Before each audit with no questions, and the stage 1 card Map entry points with its instructions and Passes on line"><figcaption><p>The <strong>How it works</strong> tab: the read-only map, with <strong>Explain</strong> on every stage and <strong>Show full instructions</strong> under long instructions.</p></figcaption></figure>

**You get**, per At a glance: “Findings with a title, severity, file and line, what's wrong and the impact, plus a fix suggestion, the attack path, an example malicious input and who can exploit it.” and “A Foundry proof of concept for findings rated high and above, re-run by QuillShield to confirm it.”

**Your code**: “Agents read your code but can't change it or use the internet. They focus on the in-scope files and read other files only for context.” and ““Foundry proof of concept” builds and runs tests in a throwaway copy of your code.”

### Try it

{% stepper %}
{% step %}

### Read it

Open **Workflows**, then the **Entry-point attack paths** card. Read **At a glance**, then open **How it works** and press **Explain** on each stage for an instant summary of how often it runs, what it reads, what it returns and its AI model.
{% endstep %}

{% step %}

### Run it as is

Press **Use in an audit** (owners and admins), pick a project and press **Continue**. The audit wizard opens on its **Workflow** step with this workflow selected, or on **Scope** first when the project has no saved scope yet. See [Use a workflow in an audit](https://www.quillaudits.com/quillshield/guides/guides/workflows/use-a-workflow-in-an-audit.md).
{% endstep %}

{% step %}

### Or adapt it

Press **Copy and edit** to get your own copy in Workflow Studio. Ask the assistant to tailor it, for example: “Our protocol uses Chainlink with a Uniswap TWAP fallback.” See [Refine with the assistant](https://www.quillaudits.com/quillshield/guides/guides/workflows/refine-with-the-assistant.md).
{% endstep %}
{% endstepper %}

## Prices

* **Every workflow costs the same as a full audit of the same code.** The price comes from your scoped lines of code (BLOC) on the usual scope curve. See [Pricing and top-up](https://www.quillaudits.com/quillshield/guides/guides/pricing-and-top-up).
* **Nothing inside the workflow changes the price**: not the number of stages or agents, the AI model, the thinking effort, the work limit, passes per agent, or follow-ups. The **Size** row of **At a glance** says it next to the run count: “The price doesn't change with this; it depends on how much code you audit.”
* **Your own AI.** Where your workspace offers it, an audit that runs a custom workflow can run on your own provider key or your Claude or ChatGPT plan instead of QuillShield AI. (The QuillShield Audit Agent runs on QuillShield AI, unless your workspace also allows it on your own OpenRouter key.) Your provider or plan is then billed for the AI usage. QuillShield charges the usual price, unless the **AI for this audit** section says “Audits on your own AI cost N% of the usual price.”
* **Building workflows is free.** The workflow assistant is limited to 20 AI requests per organization per hour.
* **Checkout works as for any full audit**: quote, wallet, coupons and refunds. The quote freezes the exact workflow version, your answers to its questions and the AI choice. If one of them changes before you pay, the open checkout expires and the dashboard shows a new quote for you to confirm.
* **Failed audits are refunded.** If every agent run in a stage fails, the audit fails and is refunded instead of reporting a clean result. The same applies when the workflow can't run at all when the paid audit starts, for example because it was removed from the Marketplace.

## Who can do what

| Role                    | With workflows                                                                                                                                                                                                                                                                                                                                                                                                      |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Owner** and **Admin** | Everything: create and edit workflows in Workflow Studio and use its assistant, import and download files, save versions, copy, delete, publish and unpublish, add to or remove from the library, make a workflow the default, allow build & test access, start audits with **Use in an audit**, choose the workflow and AI for an audit in the wizard's **Workflow** step, and manage **Settings → AI providers**. |
| **Member**              | Browse **My library** and the **Marketplace**, open any workflow page and its **How it works** map, download workflow files, start and pay for audits (they run the workflow already chosen for that project version, or the default), and review workflows from the Marketplace that your organization added to its library or ran.                                                                                |
| **Viewer**              | Read-only: browse workflows, open their pages and download files.                                                                                                                                                                                                                                                                                                                                                   |

Members and viewers who open the studio see “Only organization owners and admins can create workflows.” In the audit wizard they see “Only owners and admins can change the workflow and AI for an audit. You can review what's selected.”

## Where things are

| Place                                | How to get there                                                                                 | What you do there                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------------------ | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Workflows** page                   | Sidebar → **Workflows**                                                                          | **My library** and **Marketplace** tabs, the workflow cards and, when your workspace offers own AI, the **AI for your audits (optional)** strip. Owners and admins also get **Import**, **Create workflow**, the **Describe your own workflow** card (**Build your own workflow** when AI building isn't available) and a row for each unsaved draft on this device (“Unsaved workflow: …” or “Unsaved changes to “…””) with **Continue** and **Discard**. |
| Workflow Studio                      | **Create workflow**, **Build it**, or **Edit in studio** on your own workflow                    | The **Workflow assistant** chat on the left, the map (“How your workflow runs”) on the right, and the top bar with the name, save state, problems pill, Undo, Redo, **History**, **⋯** and the main button (**Save workflow**, **Save version N**, or **Use in an audit** once everything is saved). In a narrow window the halves become **Chat** and **Workflow** tabs.                                                                                  |
| A workflow's page                    | Click any workflow card                                                                          | Actions such as **Use in an audit**, **Copy and edit**, **Make default** and **Download**; the stats row; the **Overview**, **How it works**, **Versions** and **Reviews** tabs.                                                                                                                                                                                                                                                                           |
| The audit wizard's **Workflow** step | **Use in an audit**, or a project version's setup: **Scope**, **Docs**, **Workflow**, **Review** | **Choose a workflow**, **How it works** for any workflow, **Questions from this workflow**, and **AI for this audit**.                                                                                                                                                                                                                                                                                                                                     |
| The audit page                       | **Audits** → an audit                                                                            | For a custom workflow (anything but the QuillShield Audit Agent), the header names the workflow and its version, and findings have a **Workflow details** section. Proofs of concept from follow-ups are attached to their findings, and an audit on your own AI that stopped shows **Resume audit**.                                                                                                                                                      |
| **Settings → AI providers**          | Sidebar → **Settings**                                                                           | Owners and admins add provider keys and connect a Claude or ChatGPT plan, when your workspace offers them.                                                                                                                                                                                                                                                                                                                                                 |

<figure><img src="https://1210220531-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FRJce4WSdmcKoGJS4NwYy%2Fuploads%2FlFId40uSXDQolfaiZIZZ%2Fstudio-draft-1.jpg?alt=media" alt="Workflow Studio after the first build: the Workflow assistant on the left with a Draft 1 card, and the map on the right with At a glance, Before each audit and the stage 1 card"><figcaption><p>Workflow Studio: the assistant on the left, the map on the right, the top bar above.</p></figcaption></figure>

<details>

<summary>Limits at a glance</summary>

| What                                | Limit                                                                                                                            |
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| Stages per workflow                 | 6                                                                                                                                |
| Agents                              | 6 per stage, 24 per workflow                                                                                                     |
| Results per agent run               | 25                                                                                                                               |
| Details a stage passes on           | 24                                                                                                                               |
| Instructions                        | 20,000 characters per agent or follow-up                                                                                         |
| Work limit                          | 1 to 150 agent runs per audit (60 by default, and at least one per agent)                                                        |
| Passes per agent                    | 1 to 3                                                                                                                           |
| Questions before each audit         | 10, with answers up to 4,000 characters                                                                                          |
| Follow-ups                          | 4, each for up to 30 findings                                                                                                    |
| Findings kept per audit             | 100, strongest first                                                                                                             |
| Reference notes                     | 5, up to 40,000 characters each and 120,000 in total                                                                             |
| Severity check rules                | 8,000 characters                                                                                                                 |
| Name, one-line summary, description | 80, 200 and 20,000 characters                                                                                                    |
| Tags                                | 8, up to 32 characters each                                                                                                      |
| “What changed” note on a save       | 2,000 characters                                                                                                                 |
| Workflow size                       | 512 KiB; imported files up to 2 MB                                                                                               |
| Workflows per organization          | 100                                                                                                                              |
| Saved versions per workflow         | 200                                                                                                                              |
| Workflow assistant                  | 20 AI requests per organization per hour; 4,000 characters per message; answers usually take 1–3 minutes and are kept for 1 hour |
| Unsaved drafts                      | Kept on your device for 7 days after your last edit, removed when you sign out                                                   |

</details>

## Pages in this section

| Page                                                                                                                                   | What it covers                                                                                                                                   |
| -------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Create a workflow](https://www.quillaudits.com/quillshield/guides/guides/workflows/create-a-workflow.md)                              | From the Workflows page to a saved workflow: describe it, answer three quick questions, start from an example or from scratch, or import a file. |
| [Refine with the assistant](https://www.quillaudits.com/quillshield/guides/guides/workflows/refine-with-the-assistant.md)              | The message box, **Ask AI** menus, **Try:** chips, queued messages, what's paused while the assistant works, and every part of a draft card.     |
| [The workflow map](https://www.quillaudits.com/quillshield/guides/guides/workflows/the-workflow-map.md)                                | Every section, card, control and word of the map.                                                                                                |
| [Write good instructions](https://www.quillaudits.com/quillshield/guides/guides/workflows/write-good-instructions.md)                  | How to write agent and follow-up instructions, placeholders, questions and reference notes, with before-and-after examples.                      |
| [Problems and fixes](https://www.quillaudits.com/quillshield/guides/guides/workflows/problems-and-fixes.md)                            | The problems pill, the **Before you save** panel, every message and its fix.                                                                     |
| [Drafts, history and versions](https://www.quillaudits.com/quillshield/guides/guides/workflows/drafts-history-and-versions.md)         | Undo and redo, **History**, drafts on this device, saving, versions, the **⋯** menu, **Edit as JSON…**, import and download.                     |
| [Use a workflow in an audit](https://www.quillaudits.com/quillshield/guides/guides/workflows/use-a-workflow-in-an-audit.md)            | **Use in an audit**, the wizard's **Workflow** step, **AI for this audit**, the default workflow, checkout and the audit page.                   |
| [Library, marketplace and sharing](https://www.quillaudits.com/quillshield/guides/guides/workflows/library-marketplace-and-sharing.md) | **My library**, the **Marketplace**, a workflow's page, copies, publishing, reviews and build & test access.                                     |
| [Glossary](https://www.quillaudits.com/quillshield/guides/guides/workflows/glossary.md)                                                | Every word the app uses, what it means, its technical name and where you see it.                                                                 |
| [Workflows FAQ](https://www.quillaudits.com/quillshield/help-center/getting-started/workflows-faq)                                     | Short answers to common questions.                                                                                                               |
| [Troubleshooting workflows](https://www.quillaudits.com/quillshield/guides/reference/troubleshooting-workflows.md)                     | What to do when something doesn't work.                                                                                                          |
| [API: workflows](https://www.quillaudits.com/quillshield/developers/api-workflows)                                                     | The REST API for workflows.                                                                                                                      |
| [Changelog: Workflows and Workflow Studio](https://www.quillaudits.com/quillshield/changelog/2026/workflow-studio)                     | What's new.                                                                                                                                      |


---

# 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://www.quillaudits.com/quillshield/guides/guides/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.
