Skip to main content
Use Cases are the heart of Overcut automation. They define end-to-end workflows that automatically respond to events, execute complex multi-step processes, and coordinate AI agents to accomplish tasks. Think of them as visual programming for automation—you design the flow, and Overcut executes it reliably.

​
What is a Use Case?

A Use Case is a complete automation workflow that defines:
  • When it should run (the trigger)
  • What should happen (the steps and actions)
  • How steps connect and flow (the execution graph)
Use Cases are Overcut’s way of implementing what developers often call “workflows” or “automation pipelines.” They provide a visual, declarative way to build complex automation without writing code.

Visual Design

Design workflows using a visual canvas with drag-and-drop blocks for triggers, actions, and agents.

Event-Driven

Automatically respond to GitHub events, Jira updates, mentions, slash commands, or scheduled triggers.

AI-Powered

Integrate AI agents that can make decisions, generate content, and collaborate with users.

Multi-Step

Build complex workflows with dependencies, parallel execution, and conditional logic.

​
Core Components

Every Use Case consists of these fundamental building blocks:

​
Trigger

The event that starts your workflow execution. Triggers can be:
  • GitHub events: Pull requests opened, issues labeled, comments posted
  • Jira events: Issues created, updated, or commented on
  • Interactive triggers: @overcut mentions or slash commands like /review
  • Scheduled Workflows: Time-based triggers for recurring tasks like nightly scans or weekly reports
Every Use Case must have exactly one trigger node. This is the entry point that determines when your automation runs.

​
Actions

  • git.clone: Clone repositories for code analysis
  • repo.identify: Automatically determine relevant repositories for tickets
  • agent.run: Single-agent execution for straightforward tasks
  • agent.session: Multi-agent sessions with coordination and iteration
To read about the differences between the two agent actions, see the Agent Differences page.

​
Flow

The connections between steps that define execution order and dependencies.

​
Event Processing Flow

  1. Event Reception: Webhooks from GitHub, Jira, or other providers are received
  2. Normalization: Events are converted to standardized formats
  3. Trigger Matching: Overcut evaluates which Use Cases should run
  4. Execution Queuing: Matching workflows are queued for execution
  5. Step Processing: Each step runs according to the defined flow
  6. State Management: Context and results are preserved between steps
  7. Completion: Final results are published and cleanup occurs

​
Creating a Use Case

​
Step 1: Define the Problem

Start by understanding what you want to automate:
  • What event should trigger the workflow?
  • What should happen when it runs?
  • What are the expected outcomes?

​
Step 2: Design the Flow

Break your automation into logical steps:
  • Preparation: Clone repos, gather context, validate inputs
  • Processing: Run AI agents, perform analysis, make decisions
  • Action: Update tickets, create branches, send notifications
  • Cleanup: Archive results, update status, close sessions

​
Step 3: Configure Components

For each step, configure:
  • Parameters: Static values or dynamic variables from previous steps
  • Instructions: Specific guidance for AI agents
  • Conditions: When steps should run or be skipped
  • Timeouts: Maximum execution time for each step

​
Step 4: Connect the Flow

Define how steps relate to each other:
  • Sequential: Steps run one after another
  • Parallel: Independent steps run simultaneously - Coming soon
  • Conditional: Steps run based on previous results - Coming soon
  • Loops: Steps repeat until conditions are met - Coming soon

​
Advanced Features

​
Template Variables

Use dynamic values throughout your workflow:
  • {{trigger.issue.title}}: Access trigger event data
  • {{outputs.git-clone.repositoryPath}}: Reference previous step outputs
See the complete Event Context Reference for all available trigger properties and practical examples.

​
Monitoring

Overcut provides visibility into workflow and agent behavior through:
  • Workflow status: Track workflow progress (Running, Completed, Failed, Timeout)
  • Agent status: Monitor agent sessions (Running, InSession, WaitingForReply, Terminating, Completed, Failed)
  • Execution logs: Detailed logs for each step and agent with the full tool calls and context available to the agent

​
State Management

Context is preserved throughout execution:
  • Workflow Context: Global variables accessible to all steps
  • Step Outputs: Results from each step available to subsequent steps

​
Next Steps

Now that you understand Use Cases, explore these topics: Ready to build your first Use Case? Start with a simple workflow and gradually add complexity as you become familiar with the platform.