Getting startedQuickstart

Quickstart

Build your first Agent, publish it, chat with it, and put it on standing duty — end to end in a few minutes.

Before you start

Creating a workspace already seeds three starter Agents — "General Purpose", "Software Engineer", "Product Designer" — plus the three model presets and the allowlist that backs them. Only "General Purpose" publishes on its own during workspace creation, so a brand-new workspace can chat immediately without touching the editor. The steps below build a second Agent from scratch so the full path — draft, publish, chat, delegate — is visible end to end.

Step 1: Build your first Agent

Open the agent editor and create an Agent. Persona is a rich-text editor with a toggle for raw markdown; paste something like this to start:

You are a release-notes summarizer. Given a list of merged pull requests,
group them into Features, Fixes, and Chores, and write one plain-English
sentence per group's most important change. Skip internal-only work (CI,
tests, refactors) unless it changes user-facing behavior. Keep the whole
summary under 200 words.

Model defaults to a segmented control — Powerful, Balanced, Quick — resolved against the workspace's allowlist; see Models for what each preset actually resolves to. Context equips the Agent from the workspace library through a Browse popover over connections and skills — see Context & MCP. Skip Context for this first Agent; a summarizer needs no tools.

The editor autosaves as you go. If you'd rather describe the Agent in plain language and let the docked copilot draft the persona, model, and context for you, that works too.

Step 2: Publish

Press Publish. The platform compiles the Agent's definition — persona, model, context — into a real eve build, and stores the resulting artifact by content hash. The button tracks the phase as it goes — Compiling…, then Building… — and settles on Published, with the rail reporting "Published and built." An identical definition never rebuilds, so republishing after an unrelated edit usually settles on Published (cached) instead, against a rail that reads "Published — build served from cache." You don't have to sit and watch it: leave the editor and the result reaches you as a toast naming the Agent.

If a build fails, the editor surfaces the error inline — see Troubleshooting if it's not obvious what to fix.

Step 3: Chat with it

Start a chat and hand the Agent work. Enter sends a message and Shift+Enter inserts a newline; each run streams live over resumable SSE. While a run holds the session, the composer's send button becomes Stop, and anything you type in the meantime queues — it merges into a single message and sends the moment the session frees, rather than being refused. See Chat for the full run timeline, human-in-the-loop pauses, and context controls.

Step 4: Delegate standing work

Open the workflow editor and create a Workflow. The editor is two panes: a copilot composer on the left, and the pipeline — a trigger card and a strip of step cards — on the right. Describe the job in the composer: "Every weekday at 9am UTC, have the release-notes agent summarize yesterday's merged PRs." On a brand-new draft the copilot applies its edits as it goes, so you'll watch a Schedule trigger (0 9 * * 1-5, evaluated in UTC) and an agent step bound to your Agent appear on the strip — every card expandable into an inspector if you'd rather tune it by hand.

That one-step pipeline is the simplest Workflow there is. The model's real range shows when a job is mostly deterministic: tool steps call MCP tools on the workspace's connections directly, infer steps make cheap one-shot model calls, and steps pass data to each other with @ references — see Workflows for the step kinds and Triggers for what each trigger delivers.

Press Publish — a Workflow builds nothing, so it's instant. Then press Run in the header and submit with Fire now to fire it immediately, instead of waiting for the next scheduled tick. Runs always dispatch the published Workflow, which is why publishing comes first; the pipeline pane shows each step light up live, and View run opens the full step timeline in the Runs tab.

You now have

  • A published Agent with a persona, a model preset, and a version-pinned, content-hashed build behind it.
  • A chat thread that streamed a run live and can queue more work at any time.
  • A Workflow whose pipeline delegates to the same Agent on a schedule, testable on demand from the header's Run popover.

Go deeper on any piece: the agent editor, models, context & MCP, chat, the workflow editor, triggers, and troubleshooting if anything above didn't go as described.