ForjioHuudisIdentityPlugipayPaymentsCatentioAgentsStorlaunchE-commerceFulkrumaFulfilmentRiplloMarketingLinkSnapShort URLsPawpadoGPU streaming
Catentio Docs
⌘K

Projects

The Projects page at Dashboard → Projects is where pipeline-driven work lives. A project is a template-expanded phase graph — research, storyboard, scaffold, render — where each phase runs agent steps, deterministic actions, and human gates in a dependency-ordered DAG.

Where a run is one shot at one agent, a project is a whole campaign. The same brief can drive a multi-phase, multi-agent, multi-hour effort with versioned artifacts, approval gates, retries, and backtracking.

When to use a project

Use a project when:

  • The work decomposes into named phases (research → plan → execute).
  • Different steps want different agents (Fumi for research, Sai for scene work).
  • You want checkpoints — approve a storyboard before scaffolding.
  • You want recoverable state — pause and resume, retry a failing subtask, revert an artifact to an earlier version, retrigger a phase.

If you just want one agent to answer one question, invoke the agent directly. Save projects for sustained work.

Project templates

Workflows are database-backed and versioned — browse them at Dashboard → Templates, manage them there or via the Templates API. The built-in catalog:

Template What it does
content Full video-content pipeline: concept → research → storyboard → characters → scenes → assemble → publish.
micro-saas Ship a Forjio-family micro-SaaS: spec → scaffold → backend/frontend → deploy, with review and deploy gates baked in.
blog-post Research → write → review → publish for long-form articles.
sticker-pack Concept → stickers → package → listing copy for marketplace sticker packs.
landing-page Copy → design → build → deploy for one-page sites.
content-slideshow Slideshow-format content: script → images → slideshow export.
childrens-book Story → illustrations → layout → PDF.
motion-graphics Concept → storyboard → assets → animation → postprod.
worksheet Educational worksheet: concept → layout → render → package.
digital-planner Digital planner product: design → page render → format/export → upload.

You can author your own templates too — see Workflows. Every phase's agent steps carry tool/skill bindings, and a workflow's spec is immutable per version: editing the spec mints a new version while running projects keep the version they were expanded from.

Starting a project

From Dashboard → Projects, click New project. The create form opens as a sheet (the old /dashboard/projects/new page redirects here) with two tabs:

  • Agentic — describe the project in plain language and let the assistant draft the fields, template choice included.
  • Manual — fill the fields yourself: pick a template (grouped by collection), write the brief (a free-form string — it is baked into every step's prompt), optionally set a cost budget in USD, and optionally attach reference files.

On submit, the portal POSTs to /v1/projects; the runtime expands the workflow into tasks and subtasks atomically with creation, then the list refreshes with the new project. Attachments upload as a second step after the create succeeds.

The same call via SDK:

const project = await catentio.projects.create({
  title: 'Sustainable urban farming explainer',
  workflow_slug: 'content',
  brief: 'A practical explainer on sustainable urban farming. Tone: hands-on, hopeful.',
  cost_budget_usd: '5.00',
});

brief is a plain string, not an object. workflow_version is optional — omitted means the latest active version; pass an integer to pin one.

The project detail page

The detail page is the dashboard's most information-dense surface. Sections, top to bottom:

Awaiting-approval banner

If any human gate is blocked waiting on you, an amber banner appears at the very top naming the gate and its phase, with a Review & decide link straight to the gate's subtask page. The pipeline is paused on that path until you decide. See Gates & approvals.

Project title, the full project ID (the title lowercased and dash-collapsed, plus a random 8-character hex suffix), and a row of controls:

  • Edit with AI — opens an instruction dialog that spawns an edit session (AI planner → approval gate → enaction).
  • Edit — the edit sheet. Only title and cost budget are mutable. The brief is immutable by design — it feeds every step's prompt, so changing it mid-pipeline would silently diverge future phases from completed work. Scope changes go through edit sessions.
  • Has stale phases badge — shown when a retrigger or revert left downstream phases marked stale (lazy cascade).
  • Status pill — planning / active / paused / completed / abandoned.

Stat cards

Template (slug + pinned version), Cost spent (with a budget burn bar that turns amber past the warning threshold, default 80%, and red at the cap), and start time.

Actions

Run step (advance the pipeline one step manually), Pause (while planning/active), Resume (while paused), Abandon (terminal, confirm dialog).

Brief

The immutable brief string, verbatim.

Tasks

One row per phase with status, and an amber Stale badge on phases invalidated by an upstream change. Click through to the task page for its subtasks, then into a subtask for its attempts, events, and output. Failed subtasks expose a Retry button; terminal phases expose Retrigger (see below).

Artifacts

Grouped per phase. Each phase card shows the current artifact version, a version bar for its history (superseded versions stay — versioning is append-only), the step runs that produced it, and, where applicable, Retrigger and Revert to this version controls. Run-level outputs that don't belong to a phase are listed under Other runs.

Approval gates

Templates can include human gates. When the pipeline reaches one, the gate's subtask goes blocked, the project page raises the awaiting-approval banner, and (when Discord is configured) a ping goes out with a deep link to the gate's portal page.

On the gate's subtask page you get two buttons: Approve and Reject, each with an optional comment.

  • Approve — the gate succeeds and the pipeline continues.
  • Reject on a gate that reviews a producer step — the reviewed step reworks once, with your comment threaded in as feedback, then the gate comes back to you for a fresh decision.
  • Reject on a standalone gate — the gate fails and the project pauses (it is not abandoned; resume or abandon is your call).

The full model — gate kinds, REST endpoint, decision semantics — is on Gates & approvals.

Pause, resume, abandon

  • Pause — parks the project at paused. Autodrive skips paused projects; nothing new is dispatched. Resume any time.
  • Resume — recovers any crashed attempts and puts the project back to active; the autodrive loop picks it up within a minute.
  • Abandon — terminal (abandoned). Use when the project's premise is wrong and you don't want it to keep accumulating cost. Artifacts are kept.

Backtracking

Three levers, all on the project detail page (and its task/subtask pages):

  1. Retrigger a phase — re-run a terminal (succeeded / failed / skipped / stale) phase, optionally with an addendum brief. Downstream phases get the cascade treatment: lazy (default) marks them stale without re-running, strict auto-retriggers them, none pins them against the old output. In-flight phases can't be retriggered (the API answers 409).
  2. Revert an artifact — flip a phase's current artifact back to an earlier version from the version bar. Append-only: newer versions stay in history. Downstream phases go stale under the default lazy cascade.
  3. Edit with AI — describe the change in plain language; an AI planner drafts a plan of retriggers/reverts, you approve it on a gate, and the runtime enacts it.

Details and the REST surface: Artifact versioning & backtrack.

Per-project cost limits

Each project has an optional cost_budget_usd cap (USD). At 80% burn (configurable via cost_warning_threshold) a warning event fires; at the cap the runner pauses the project with a cost_budget_breached event rather than starting new work. Raise the budget (project Edit sheet or PATCH /v1/projects/{id}) and resume, or abandon.

More on the cost model: Cost & budgets.

Next