Skip to main content
The IronBee Action adapts to what triggered the workflow. The event decides what gets verified and where a fix goes. The report and the job result work the same way on every event. This guide covers each trigger and what the action produces.

Pull request

What gets verified: the whole pull request. Fixes: committed to the pull request branch. Report: a comment on the pull request, updated in place on later runs, unless IronBee publishes the run on the pull request itself. See The report. This is the most common trigger and the recommended starting point.

Push to main

What gets verified: every commit in the push, from the push’s before commit, or the commit against its parent when that base isn’t usable. Fixes: committed to a new ironbee/fix-<sha7>-<run_id> branch, with a pull request targeting the branch that was pushed. Use it alongside the pull request trigger to catch what broke after a merge.

Scheduled and manual runs

What gets verified:
  • On IronBee: the latest commit against its parent.
  • On your runner: the whole application.
Fixes: committed to a new fix branch, with a pull request. Start a manual run from the Actions tab on GitHub. It’s useful to repeat a verification after a configuration change, or before a release.

Deployments

What gets verified:
  • On IronBee: the deployed commit against its parent.
  • On your runner: the whole application.
Fixes: committed to a new fix branch, with a pull request, as for a manual run. Environment: with ironbee_environment empty, the run uses the deployment’s environment. See Environments. deployment_status fires for every status a deployment reports, such as pending and then success, so the if: keeps the run to a deployment that finished. The action doesn’t read the deployment’s URL from the event: pass it in app_url, here the environment_url the deployment reported. A deployed URL isn’t re-verified after a fix, because it still serves the code that was deployed.

Pull request comments

A /ironbee-verify comment on a pull request starts a verification of that pull request. Fixes are applied only when the comment asks for them with --fix. This trigger needs a guard in the workflow, so it has its own guide: Verify from a pull request comment.

Trigger summary

Fixes need verification_apply_fix: true, the default, and an Anthropic credential. Without a credential, a run on IronBee verifies and reports only. With verification_apply_fix: false, a run verifies and reports in both modes: on your runner, the agent reports what it finds and changes no file. A fix whose re-verification fails is not pushed. Only what the fix changed is committed. On IronBee, the install and the build run before the fix, so what they write stays out of the commit. On your runner, the agent installs, builds and fixes in one session, so the action commits only after a verification failed and the agent verified again; that commit can also hold what the agent’s own install or build wrote. Files your app writes outside ignored paths while the fix runs count as changes too. With ironbee_exclude_files: false, IronBee’s setup files are committed with the fix.

Combining triggers

One workflow can listen to several events. Add a concurrency group so a new push cancels the run it replaces:

Turning automatic verification off

To verify only when someone asks for it by name, with a comment command or a manual dispatch, turn off verification on every other event: pushes, pull requests, schedules and deployments. You have two ways to do it. With a job-level if:. GitHub evaluates it before a runner is assigned, so a skipped event costs nothing: no runner, no checkout, no builds.
The first line keeps a manual dispatch running when the variable is false. Without it, the second line skips the dispatch too. With the verification_auto input. The action resolves to “nothing to do” and the job ends green in seconds. The steps before the action, such as the checkout and your builds, still run.
Use the if: when the job does expensive setup before the action, and the input otherwise. Neither stops a comment command or a manual dispatch.

The report

The action writes the report to the workflow run’s summary and posts it as a pull request comment. When a comment from an earlier run exists, it’s updated instead of duplicated. On a push, schedule or manual run, the report becomes the body of the fix pull request. When the IronBee GitHub App covers the repository, IronBee publishes a run on IronBee itself, on any event: the IronBee Verification check on the verified commit and, on a pull request, an inline comment on each finding in the diff, with a suggestion where one applies, and a comment with the result. The action then posts no report comment and doesn’t update an earlier one; the report stays in the job summary, and the platform_publishes output is true. A run on your runner always reports through the action’s comment. When a fix round re-verifies an app on the runner, the re-verification posts on the pull request too, and its comments replace the first run’s. See What appears on the pull request. A run on IronBee reports:
  • the verdict and a link to the run in the IronBee Console
  • the summary, and the Checks, Issues and Suggested fixes from the verdict
  • after a fix, a link to the verification before the fix
  • a No verification ran or No verdict banner, with the reason, when the run couldn’t produce a verdict
A run on your runner reports:
  • the verdict, with the number of cycles when there was more than one
  • each verification cycle, with its checks, issues and fixes, and a link to that verification in the console
  • an early-exit banner, with a collapsible details block, when the agent stopped early (for example at claude_code_max_turns)
  • a link to download the evidence artifact

The job result

The last step of the action fails the job when the verification fails or ends without a verdict, so you can use the job as a required check. The job also fails when a fix can’t be pushed, for example because someone pushed to the branch during the run. A fix commit or fix pull request pushed with the workflow’s GITHUB_TOKEN starts no workflow run of its own, so a required check on it waits for the next push. The verdict output (pass, fail, not_applicable or unknown) is available to later steps.

Forks

A pull request from a fork receives no secrets, so no verification can run on it. The action detects it and says so. Comment commands on fork pull requests are refused as well. See Verify from a pull request comment.

What’s next?

Verifying your application

Choose the target: an app on the runner or a deployed URL.

Verify from a comment

Start a verification with /ironbee-verify.