Generating Your First Tasks: How Your AI Workforce Breaks Down and Executes Work

Generating Your First Tasks: How Your AI Workforce Breaks Down and Executes Work

Your project is created. The charter is built. Now the platform does something you'd normally spend hours on: it generates every task needed to complete the project, assigns the right agents, and queues everything for execution.

This guide walks through how tasks get generated, what they look like, how the approval system works, and why the task layer is where your AI workforce really starts to learn.

You Don't Write Tasks — The System Does

In traditional project management, you set the goal and then spend days breaking it into tasks, estimating effort, assigning people, and managing dependencies. That entire layer is automated in Supanova.

When your project charter is created, the platform:

1. Reads the charter — objectives, timeline, phases, deliverables
2. Checks your workspace's connected integrations to know what tools are available
3. Breaks deliverables into executable tasks — typically 10-100+ depending on project complexity
4. Each task gets a title, detailed description, required skills, estimated hours, acceptance criteria, and dependencies
5. Tasks are tagged with phase IDs so they align with the project timeline

You can also create tasks manually from the project detail view. But for most users, the AI-generated breakdown is where execution starts.

What a Task Looks Like

Every task has a consistent structure:

• Title: Specific and actionable. Not "do marketing" — more like "Draft Q2 email campaign copy for enterprise segment."
• Description: Detailed instructions with embedded completion criteria. This is what the agent reads before it starts working.
• Priority: Low, medium, or high
• Status: Starts as pending
• Estimated hours: Used for cost estimation
• Acceptance criteria: How the agent knows when it's done
• Required skills: What kind of agent should handle this task
• Assigned agent: Which specific AI agent (atom) will execute it

The more detailed your project brief was, the more specific these tasks will be. Brief quality cascades all the way down to task quality — this is why the previous guide emphasized writing thorough briefs.

The Task Lifecycle: 9 Statuses

Every task moves through a defined set of nine statuses that it moves through autnonomously. This helps a few things:

1. Your atoms always know where tasks stand
2. You, the user, can always audit progress across all projects and all atoms. Enabling you to have dozens of projects and hundreds of tasks with thousands of atoms working at the same time.
3. Enabling the possibility of multiplayer - where you can invite human team members to work with the autonomous workforce in real time.
4. Having everything rowing in the same direction

You'll interact with three of these most often: awaiting_approval (your sign-off needed), needs_input (agent has a question), and completed (review the output).

Execution Modes: How Much Oversight You Want

Your workspace has an execution mode setting that controls the approval flow. You can change this per project or at the workspace level.

Autonomous mode: Agents execute tasks without asking. They pick up work and deliver results. The exception: high-cost operations like deep research or multi-document work still require your approval, even in autonomous mode. This is a guardrail, not a limitation.

Task approval mode (the default): Every task needs your explicit "Approve" before the assigned agent begins. You'll see an amber status indicator on tasks waiting for your sign-off. This is the recommended starting point — it lets you see exactly what your workforce plans to do before it does it.

Subtask approval mode: Parent tasks run automatically. Only subtasks — the granular steps within larger tasks — need your approval. This gives you detail-level control while letting the big picture flow without bottlenecks.

The Approval Flow

When a task enters awaiting_approval, here's what you see:

• The task title and full description
• Estimated cost for execution
• Which agent is assigned and their skill set
• An amber indicator in the project view

You have two choices:

• Approve: The task moves to queued. The agent picks it up in the next polling cycle and begins working.
• Deny: The task returns to pending. The agent assignment is cleared. You can edit the task description, reassign it, or delete it entirely.

If something about the task seems off — the description doesn't match your intent, the scope is too broad, the wrong agent is assigned — deny it and adjust before approving. It's much easier to correct a task before execution than after.

When an Agent Needs Your Input

Sometimes an agent hits a blocker mid-execution. The task enters needs_input status, and you'll see an orange indicator with the agent's question.

There are two types of blockers:

Clarification: The agent needs more information to continue. For example: "Which audience segment should this email target?" or "Should this report include Q1 data or just Q2?"

Operational gate: The agent needs an integration you haven't connected yet. For example: "Need CRM access to look up account data" or "Need Google Sheets connection to create the report."

Your options:

• Provide input: Type your answer directly. The agent resumes with your context included.
• Resolve the gate: Go connect the required integration in The Lab, come back, and confirm it's ready. The agent retries with the new tool available.
• Skip: Tell the agent to proceed with its best judgment. Useful when the question is low-stakes and you trust the agent to make a reasonable call.

Every input you provide becomes part of the task's context — which means the platform learns what kind of clarifications your business requires and can preempt them in future task generation.

Subtasks: Tasks Within Tasks

Complex tasks may have subtasks — child tasks nested under a parent. They use the same structure and lifecycle, linked via a parent-child relationship.

When all subtasks complete, the parent task auto-completes. In subtask approval mode, you approve each subtask individually while parent tasks run freely.

You can view subtasks in the collapsible detail view within the parent task modal. This is useful for large deliverables where you want to track granular progress without losing sight of the bigger picture.

How Agents Execute Tasks

Behind the scenes, a background worker polls for tasks that are ready for execution. The cycle is eight steps long, all happening in the background.

If the agent fails at their task, you can retry via the "Rerun" button. Tasks can be retried up to 3 times. Transient errors — API timeouts, rate limits, temporary service outages — are common reasons for failure, and a retry often succeeds.

Tasks stuck in_progress for more than 24 hours are automatically detected and reset by the system, so nothing gets permanently stuck.

Monitoring Your Tasks

The project detail view is your command center for task oversight:

• Status indicators: Color-coded by status — amber for awaiting approval, orange for needs input, green for completed
• Progress bar: Shows completed vs. total tasks at a glance
• Filters: Filter by status to quickly find tasks that need your attention
• Bond outputs: Shows what agents did with connected integrations — emails sent, documents created, records updated. Each output includes a summary, external reference links, and a content preview.

How Tasks Train the Workforce

The task layer is where the richest learning happens.

Every completed task generates data: what the agent did, how long it took, what tools it used, whether the output was accepted or needed revision. Over time, this builds a performance profile for each type of work.

Every failed task generates equally valuable data: what went wrong, whether it was a skill mismatch, a missing integration, unclear instructions, or an overly ambitious scope. The platform uses failure patterns to improve future task generation — adjusting complexity, adding clearer acceptance criteria, or recommending different agent assignments.

Every input you provide when an agent asks a question teaches the system about your preferences, your business context, and the level of specificity your work requires. Future tasks in similar domains will be generated with that context already baked in.

This is the compounding effect: your first project might need a dozen approval cycles and several inputs. By your tenth project, the platform generates tasks that match your expectations with minimal intervention. The workforce isn't just executing - it's calibrating to how you work.

Tips for Your First Tasks

1. Start in task approval mode. See what agents plan to do before they do it. Once you trust the pattern, you can switch to subtask approval or autonomous mode.

2. Review the first few tasks carefully. Check that descriptions match your intent and acceptance criteria are specific enough. If a task seems off, deny and edit it — this feedback improves future generation.

3. Use the Rerun button on failures. Transient errors are common. Don't assume a failed task means broken logic — retry first.

4. Watch the cost tracking. Each task shows estimated and actual cost. This helps you calibrate expectations and identify tasks that are more expensive than they should be.

5. Respond to needs_input promptly. An agent waiting on your input is a blocked agent. The faster you respond, the faster your workforce moves.

What's Next

Your tasks are running. Agents are executing. But right now, they're producing text deliverables — documents, drafts, analysis. To let them interact with your actual tools — send emails, update your CRM, post to Slack, create spreadsheets — you need to connect integrations. That's what bonds do: Integrating Your First Bonds.

... Six