Overcut automations are built using four fundamental building blocks. Once you understand how these pieces connect, you can create, customize, and troubleshoot any Overcut flow, from code review to spec generation to ticket triage.

Use Case

A Use Case defines an end-to-end automation scenario. It wraps your trigger, all actions and agents, and your entire logic graph.

Trigger

A Trigger defines when a Use Case should run. It’s the event that starts execution.

Action

An Action performs a single operation during the flow.

Agent

An Agent is an AI-powered block capable of making decisions, generating content, and collaborating with users.
In addition to these building blocks, you should also be familiar with the Execution. Execution is the process of running the Use Case graph step-by-step.

​
Use Case

What it is:
A Use Case defines an end-to-end automation scenario. It wraps your trigger, all actions and agents, and your entire logic graph. Why it matters:
Use Cases give structure and intent to your flows. They let you describe what problem you’re solving—like automating bug triage or reviewing a pull request—while encapsulating all technical logic inside. Core elements inside a Use Case:
  • One Trigger (when the flow should start)
  • One or more Actions or Agents (what should happen)
  • A visual or declarative flow graph connecting them
1

Create a Use Case

In the Overcut UI, go to Use Cases and click Create Use Case.
2

Define Trigger and Steps

Add the blocks needed to represent your logic.
3

Connect the flow

Use the visual canvas or graph editor to define how steps flow into each other.

​
🧲 Trigger

What it is:
A Trigger defines when a Use Case should run. It’s the event that starts execution. Supported trigger types include:
  • Pull request opened
  • Issue labeled or updated
  • Mention detected (e.g. @overcut)
  • Slash command issued (e.g. /review)
  • Scheduled events
  • Manual button click
Trigger Delays:
You can configure an optional delay before workflow execution to allow related updates to complete. This is useful for:
  • Issue creation: Wait for fields to be filled out and labels to be added
  • PR updates: Allow time for description edits and initial comments
  • Field changes: Let users complete their input before processing
Interactive triggers (slash commands and mentions) ignore delay settings and execute immediately for responsive user experience.
1

Choose a trigger type

Select from prebuilt GitHub, Jira, or scheduling triggers.
Jira Triggers: Currently supports issue creation, updates, and comment events through the Forge app integration. Additional trigger types are being added.
2

Define optional conditions

You can restrict the trigger to specific repos, users, or labels.
3

Configure delay (optional)

Set a delay in seconds to wait before executing the workflow. This allows related updates to complete before processing begins.
Every Use Case starts with a trigger, it’s required.

​
⚙️ Action

What it is:
An Action performs a single operation during the flow. An action can be deterministic like “Clone a repository” or “Create a branch”, or it can AI based. Currently supported actions:
  • git.clone: Clone repositories for code analysis
  • repo.identify: Automatically determine relevant repositories for tickets
  • agent.run: Execute a single AI agent for straightforward tasks
  • agent.session: Start multi-agent sessions with coordination
More actions are coming soon for notifications, specific git or ticket operations, and more.
The Identify repositories action is particularly useful in multi-repository workspaces. It automatically determines which code repositories are most relevant to a ticket context using AI-powered analysis and explicit correlations. Learn more in our Repository Mapping guide.
1

Drag an action to the canvas

Add an action from the sidebar to your Use Case.
2

Configure input parameters

Set static values or use dynamic variables from earlier steps (e.g. {{trigger.issue.title}}).
3

Connect the action to the flow

Make sure it’s connected after a trigger or another step.
The output of an action is available in the context for the next actions in the Use Case.

​
🤖 Agent

What it is:
An Agent is an AI-powered block capable of making decisions, generating content, and collaborating with users. Agents have access to predefined tools and can be trained for specific tasks. Agents are built on top of built-in specialized agent types. Agent Action Types:
  • agent.run: Execute a single agent for focused, non-interactive tasks
  • agent.session: Coordinate multiple agents for complex, interactive workflows
Pre-built agents:
  • Code Reviewer
  • Tech Writer
  • Product Manager
  • Senior Developer
Each pre-built agent is specialized in a specific task, and have access to a set of tools. Custom agents:
  • You should create your own agents with your own tools.
  • Agents are always built on top of one of the pre-built agents.
  • You can train or customize the agent with special instructions.
For example, you can create “Backend Developer”, and “Frontend Developer” agents, each with special knowledge and instructions while both are built on top of the “Senior Developer” agent.
To understand the differences between agent.run and agent.session and when to use each, see our Agent Differences guide.
1

Create an agent

Use the Agents Roles page to create a new agent role.
2

Choose base agent role

Overcut provides reusable pre-built agent roles like Code Reviewer or Product Manager.
3

Add instructions

When needed, you can add special instructions to the agent, with rules, constraints, or knowledge.
4

Add tools

You can add tools to the agent to give it access to specific data or actions.

​
🧠 Execution

Execution is the process of running the Use Case graph step-by-step. Once triggered, Overcut executes the Use Case graph step-by-step. Each node is evaluated in order, and each agent or action completes its task before the next begins. Execution is observable and can be monitored from the Executions page.
1

Execution is sequential

Steps run in the order defined in your flow. Agents may take longer to complete depending on task complexity.
2

Execution is observable

You can monitor logs, inputs, outputs, and errors for each step from the Executions page.

​
🚀 Advanced Workflow Features

Parallel Execution:
Multiple independent steps can run simultaneously to improve workflow performance. Conditional Logic:
Steps can be executed based on conditions and previous step results. Error Handling:
Workflows can include fallback paths and retry mechanisms for failed steps. State Management:
Context and results are preserved between steps for complex multi-step workflows.