Your first project

By now you have a running instance, a user profile, and at least one specialist agent you’ve chatted with. Time to hand it real work.

The work-tracking model, one paragraph

A project is a container. Inside a project, you set goals — high-level objectives written in plain English. Goals break down into issues — discrete pieces of work, each with a status, an assignee, and a result. An assignee can be an agent or a human. When an issue is assigned to an agent, the agent picks it up on its next heartbeat and executes it autonomously. When it’s done, the issue closes and anything it depends on becomes unblocked.

That’s it. Project → goals → issues → assignees. Everything else is details.

Create the project

Open Projects from the sidebar and click New project. Fill in:

• Name — short, e.g. q4-launch or pricing-page-redesign
• Description — one or two sentences about what the project is for. Agents read this when they pick up work, so write it like you’d brief a new contractor: “Launch the new pricing page with clearer copy, cleaner visuals, and a free-trial CTA above the fold.”
• Team (optional) — attach a team if you have multi-tenant mode on
• Budget cap (optional) — dollar limit for this project specifically

Click Create. You land on the project detail page. It’s mostly empty — no goals, no issues, no activity. Next step fixes that.

Write a goal

Click New goal on the project detail page. A goal is one sentence describing a desired end state. Good goals:

• Launch the new pricing page by end of quarter
• Cut our build time from 14 minutes to under 5
• Produce a competitor landscape for the analytics space
• Refactor the auth middleware to use the new claim model

Bad goals are vague or multi-part. “Improve the website” is not a goal — it’s a vibe. “Make the homepage load faster and redesign the pricing page” is two goals; split them.

Save the goal. You’ll see it on the project detail page with zero issues attached.

Let the Project Manager break it down

Exolvra ships with a Project Manager agent (project-manager) whose job is exactly this. On its next heartbeat — roughly every 30 seconds — the PM reads the new goal and breaks it into issues, assigning each one to the right specialist from your agent roster.

While you wait, you can watch the project detail page. New issues appear one at a time. Each issue has:

• A title — terse, imperative (“Draft pricing page copy”)
• A description — enough detail for the agent to execute without asking
• An assignee — the specialist the PM picked
• A status — Open when created
• Optional dependencies — e.g., the implementation issue is blocked by the copy issue

If the PM can’t find a good assignee for some part of the work, it’ll either create a new specialist on the fly or leave the issue unassigned for you to handle.

Don’t have a Project Manager? Either create one via /agents/new using a PM personality preset, or create issues yourself by clicking New issue on the project page. You can assign them to any agent manually.

Watch autonomous execution

Each assigned issue stays Open until the agent’s heartbeat picks it up. At that point the issue transitions to InProgress and the agent starts executing. Open the issue detail page and you’ll see:

• A live activity timeline — tool calls, intermediate results, status changes, streamed as they happen
• Comments — the agent’s progress updates as it works
• Attachments — any files the agent produced (draft documents, screenshots, generated assets)
• Data store entries — structured findings the agent saved for later reference

The agent can take anywhere from a few seconds to many minutes depending on the task. You don’t have to watch — you can close the tab and come back later.

When the agent thinks it’s done, the issue moves to PendingReview. You read the result, either approve (→ Resolved) or reopen with a comment (→ back to InProgress). Approved issues unblock any issues that depend on them, and those agents start their own execution.

Read the results

When every issue in a goal is Resolved or Closed, the goal is complete. Check the project detail page for a summary:

• Issue timeline — every status transition, every assignee change, every blocker hit
• Data collected — everything in the data store under this project
• Files produced — attachments across all issues in one place
• Cost — total budget spent, per-agent breakdown
• Audit log — filterable record of every tool call the agents made

That’s the payoff: a single project detail page shows you what was done, who did it, how long it took, how much it cost, and lets you drill into any step.

What just happened

In one sitting you:

1. Created a project scoped to a specific piece of work
2. Wrote a goal in plain English
3. Let a PM agent break it into issues and assign them to specialists
4. Watched autonomous agents execute those issues, collaborate across dependencies, and report back
5. Reviewed the work, approved it, and shipped it

You can repeat this pattern for everything from research briefs to code migrations to content production. The loop is always: project → goal → issues → execution → review.

Where to go next

• Projects — the full dashboard reference for the projects page
• Issues — issue statuses, dependencies, comments, attachments
• Agents and chatbots — the deeper concept of how agents think and work
• Orchestration patterns — seven ways to coordinate multiple agents on the same project
• Admin overview — the hardening checklist if you’re moving from a toy instance to a real deployment

You’re out of the getting-started section. Everything after this is reference — read the pages that match what you’re trying to do.