Task

Tasks are the structured execution layer of Origin. Every meaningful unit of work, whether discovered by AI or created manually, is captured as a task and tracked through a defined lifecycle.

Unlike external issue trackers, tasks in Origin are directly connected to the repository, agent reasoning, labels, priority, and execution state. This keeps planning, AI assistance, and code-level execution inside a single system.

For example, if you decide to harden authentication middleware after a security review, that change should not live as a loose prompt in chat. It becomes a task with a title, priority, labels, and a lifecycle state, making it visible, reviewable, and traceable.

Navigating the Task Sidebar

The left sidebar organizes tasks into several views:

• All Tasks: every task across the project
• My Tasks: tasks assigned to you
• PM: planning and management-focused views
• Dev: development-focused task views
• QA: quality assurance tasks
• SecOps: security operations tasks
• Shipped: completed and delivered work

Below that, Labels shows all active labels and their task counts, giving you a fast way to filter by category, for example, clicking Code Quality immediately narrows the view to tasks under that label.

The Stats section at the bottom of the sidebar gives you access to Milestones, Cycles, and Assignees, covered in detail later in this page.

At the very bottom, Import Tasks and AI Task Discovery let you bring in external work or generate new tasks from repository analysis.

Task Lifecycle

When you open the Tasks view, work is organized across lifecycle stages shown as tabs at the top:

• Backlog: tasks not yet ready for active work
• Triage: newly created or generated tasks awaiting review
• To Do: validated tasks ready to be picked up
• Queued: tasks lined up for execution
• In Progress: actively being worked on
• In Review: changes submitted, awaiting human review
• Completed: finished work
• Cancelled: tasks that are no longer relevant

Each tab shows a count of tasks in that stage. A task typically starts in Triage when it is newly created or AI-generated. Once reviewed, it moves to To Do, then through execution and review stages until it reaches Completed.

This makes it easy to answer practical questions at a glance: what is being worked on right now, what is waiting for review, what still needs to be triaged.

List and Board Views

Tasks can be viewed in either List or Board format, toggled from the top right of the task view.

List View presents tasks in a structured table showing priority, title, status, labels, and assignee. This works well when scanning large volumes of work. During a security sprint, for example, you can filter by the Security label and immediately see all hardening tasks sorted by priority.

Board View groups tasks into columns based on the grouping you configure, by default, Label. Tasks appear as cards showing their title, priority, and label. A display panel on the right lets you control exactly what you see:

• Columns: group by Label or other properties
• Ordering: sort by Priority or other fields
• Visibility: toggle subtasks and filter completed issues by time range (e.g., All time)
• Board options: show or hide empty columns
• Core properties: toggle ID, Status, Assignee, Priority, Labels, and Source on or off
• Advanced properties: enable Milestone, Cycle, and Estimate when you need them

You can reset display settings to default at any time, and changes apply only to your view.

Creating a Task

Tasks can be created manually using the Create Task button at the top right of the Tasks view.

The creation panel includes:

• Title and description
• Status (e.g., To Do)
• Priority (Medium by default)
• Assignee
• Attachments
• Milestone
• Labels
• A Create more toggle for rapid consecutive entry

For example, if you notice API responses are not consistently validated, you can create a task titled "Standardize response validation across API routes," set it to High priority, add a Security label, and assign it immediately. If you are breaking down a larger initiative, the Create more toggle lets you capture multiple related tasks in one go without reopening the form each time.

Task Context Menu

Right-clicking any task in the list or board view opens a context menu that lets you act on it without opening the full task detail. This is the fastest way to update, reassign, or reorganize tasks in bulk.

The following options are available:

• Status: Move the task through its workflow stages. Options are split into two groups:
  • PM: Backlog, Triage
  • Dev: To Do, Queued, In Progress, In Review
• Assignee: Assign the task to a team member, leave it unassigned, or hand it to Orgn Copilot, the autonomous coding agent. You can also invite a new member directly from this menu.
• Priority: Set urgency to Urgent, High, Medium, or Low.
• Cycle: Assign the task to an existing cycle directly from the context menu without opening the Cycles view.
• Milestone: Attach the task to a milestone, useful when triaging a batch of newly generated tasks and grouping them into the right initiative in one pass.
• Estimate: Set a time or effort estimate for the task.
• Labels: Add or change labels without opening the task detail.
• Rename: Edit the task title inline.
• Add Link: Attach an external reference or URL to the task.
• Make a Copy: Duplicate the task, useful when creating similar work items across a sprint or initiative.
• Copy Link: Copy a direct link to the task to share with a teammate.
• Delete: Permanently remove the task.

The context menu is particularly useful when working through a large Triage backlog after AI Task Discovery. You can right-click through tasks one by one, set priorities, attach milestones, assign cycles, and move them to To Do without ever leaving the list view.

New Feature

The New Feature button sits alongside Create Task at the top of the Tasks view. Use this when you want to create a higher-level feature that groups related tasks together, rather than creating individual tasks in isolation. Features give you a way to organize work around a larger deliverable or capability.

Filters and Search

The search bar at the top of the Tasks view lets you search across all tasks by title. The Filters button opens additional filtering options so you can narrow the task list by priority, label, assignee, status, or other properties. This is useful when working across a large backlog and you need to focus on a specific area of work quickly.

AI Task Discovery

AI Task Discovery, accessible from the bottom of the sidebar, generates structured tasks by analyzing the repository.

When triggered, the system scans the project, evaluates architecture, and reviews patterns such as error handling, test coverage, and security posture, then creates tasks based on what it finds. If you import a frontend project, the system might generate tasks like:

• Add error boundaries and fallback UI to dashboard
• Remove duplicated TSX/JSX dashboard components
• Implement CSRF protection for form submissions
• Centralize Tailwind color/CSS variables

These are planning artifacts. No code changes are made automatically. You decide which tasks to move forward, edit, merge, or discard.

This is particularly useful when onboarding into an unfamiliar codebase. Instead of manually scanning every file, you get a structured backlog based on the actual repository state.

Triage Limit

AI Task Discovery has a limit of 20 AI-suggested tasks in Triage at any one time. If you run discovery and the limit is reached, Origin will show a prompt letting you know how many tasks are currently sitting in Triage.

From this prompt you can either:

• Delete AI Tasks: remove the existing AI-generated triage tasks to make room for new ones
• Move to Backlog: shift current triage tasks to the Backlog so they are preserved but no longer counted against the limit

This keeps the Triage view from becoming unmanageable. The intent is that tasks should be reviewed and moved forward regularly rather than left to accumulate. Once you clear space, you can run AI Task Discovery again to generate a fresh batch.

Importing Tasks

If your team already manages work in an external tool, you can bring those issues directly into Origin without recreating them manually.

Click Import Tasks at the bottom of the sidebar to open the import screen. Currently supported integrations are:

• Linear: import issues directly from your Linear workspace

  To import tasks from Linear you need an API Key from:

  Linear → Settings → Security & access → Personal API keys → New API key

  and submit it in the Origin import screen.

• Jira: coming soon

• ClickUp: coming soon

This is useful when migrating an existing project into Origin or when your team tracks work in Linear but wants to execute it inside Origin's agentic environment. Once imported, tasks behave the same as any other task, they move through the same lifecycle, can be assigned, labelled, and executed by agents.

Milestones

Milestones group related tasks under a larger objective and help track progress toward a specific outcome, a release, a security review, or a technical debt initiative.

Each milestone shows:

• Its name and target date
• A progress bar with Scope, Started, and Completed counts
• The labels associated with it
• Tasks in Milestone: the tasks currently grouped under it
• Suggested Tasks to Add: tasks from the backlog that are relevant based on labels and content

For example, a Pre-Launch Check milestone due Apr 2 might contain tasks like "Add error boundaries and fallback UI to dashboard" and "Add PropTypes and TypeScript prop validation," all tagged under Code Quality. If a related task like "Configure strict CORS policy in Vite config" exists in the backlog, it surfaces as a suggestion so you can add it with one click.

You can create multiple milestones for different phases, Pre-Launch Check, Launch Scaling, Post-Launch Pushes, and track progress across all of them from a single view. New milestones can be added at any time using the + Add milestone option at the bottom.

Cycles

Cycles organize tasks into time-boxed development periods, similar to sprints.

Each cycle has a defined date range and shows:

• Scope, Started, and Completed counts
• Capacity usage as a percentage
• Tasks in Cycle: the tasks planned for that iteration
• Suggested Tasks to Add: backlog tasks that fit the cycle based on label and priority

The current active cycle is clearly marked. For example, Cycle 1 running from Mar 31 to Apr 7 at 25% capacity shows tasks like "Add inline comments to complex dashboard chart components" and "Implement tests for cn utility function in lib/utils.ts" as active work, while urgent tasks like "Add error boundaries" appear as suggestions to pull in.

Future cycles, Cycle 2, Cycle 3, Cycle 4, appear in the timeline so you can plan ahead. New cycles can be added using + Add cycle.

Assignees

The Assignees view organizes tasks by the person responsible for them.

Each team member appears with:

• Their role (e.g., Contributor)
• A progress bar showing started and completed work
• Scope count
• Tasks Assigned: the tasks currently on their plate
• Suggested Tasks to Assign: backlog tasks that are a good fit based on label and priority

An Unassigned section at the bottom collects all tasks without an owner. This makes it easy to spot gaps and distribute work without manually scanning the full task list.

For example, if a team member has three tasks assigned, "Implement tests for cn utility function," "Implement consistent error boundaries for dashboard," and "Extract duplicated chart axis configuration", their workload is visible at a glance alongside urgent unassigned tasks waiting to be picked up.

How These Views Work Together

Milestones, Cycles, and Assignees organize the same tasks in different ways:

In practice, tasks are usually discovered first, then grouped into milestones, scheduled into cycles, and assigned to the right people. This keeps planning tightly connected to execution without needing a separate project management tool.

Execution Boundaries

When a task is executed by an agent, all changes are scoped to that task. Reasoning traces are preserved, diffs are attached, and status transitions are recorded.

If an agent refactors database access logic and modifies five files, those changes are tied to the task that authorized them. During review, you can inspect the reasoning, compare diffs, and either approve or request revision.

This prevents silent or contextless changes. Every modification has an associated objective and a traceable history.