Work model

Core concepts defines the vocabulary — Provider, Runtime, Thread, Run, Event. This page is about how those pieces actually move on your own Stack: where work comes from, and why it flows the way it does.

The shape of it

You register a Project — a GitHub repository — with your Stack's own Dispatcher. From then on, the Dispatcher watches that Project for eligible work, and whenever it finds some, it drains it: a fresh Workspace is cut for the issue, a Thread is opened, and one or more Runs are driven through whichever Provider you've connected. Every Run streams normalized Events into that Thread's append-only journal as it happens — the same journal your Dashboard renders live.

Work also starts by hand: open a new Thread yourself, type a prompt, and that's a Run too, no Project or issue required. The Quickstart walks this path start to finish.

Why it's a poll, not a push

Your Dispatcher doesn't wait to be told when something changed on GitHub — it polls on an interval, on its own, so a repository can gain an eligible issue at any time without anything else having to notify your Stack. This is deliberate: your Stack is the one component with all the GitHub/issue domain knowledge, so it is also the one component responsible for deciding when to act on it, rather than depending on an external push you'd have to configure and trust.

Why work is bounded, not unlimited

Your Dispatcher will not run every eligible piece of work it finds all at once — it admits new Runs against a concurrency ceiling (see Quotas) so your own Stack's resources, and your connected Provider's own concurrency, are never overrun by your own backlog. Raising or lowering that ceiling never disturbs a Run already in flight; it only changes what your Dispatcher will start next.

Why coordination is scripted, not automatic

When more than one Run needs to happen in a deliberate order — or an agent itself needs to delegate a piece of work — nothing in the harness decides that coordination on its own. It is always scripted explicitly, by whichever caller is driving it: your Stack's own Dispatcher deciding which issue to drain next is one instance of that same discipline, not a special case.

Related

• Core concepts — the Thread/Run/Event vocabulary this page assumes.
• Quotas — what actually bounds how much work runs at once.
• Quickstart — starting a Run by hand, and watching it stream.