# The Runs page: runs, jobs and logs

> Read the runs and jobs Latchkey served in your workspace: what is running now, the history and its filters, a job's detail and log, and a run's jobs and legs.

Source: https://latchkey.dev/documentation/runs

## Summary

- **Runs** lists pipeline runs, CLI jobs and Latchkey on GH jobs Latchkey served in this workspace, and nothing it did not serve.
- **Running now** shows the pipeline and CLI jobs running, starting or held right now; **History** pages through the window 25 rows at a time, narrowed by filters and a search.
- Pick a run or a CLI job to open its job detail beside the list, with **Download log** in its foot; **Export CSV** saves the history as a file.
- A run's page draws its jobs by what each needs, a matrix job opens its leg grid, and a job whose own command failed can be handed to your coding agent.

The Runs page. Running now, marked Live, fills with the jobs of a push, Lint, four Unit shards and Integration from CI and three E2E browsers, and a CLI job running npm ci && npm test. Each job reads Starting while it starts on a runner, then runs, and Lint finishes and leaves the list. The line above the jobs counts the runners in use, up to 10 of 80 and then 9 of 80, and those still starting, with warm 6, parked 4 and 0 held, and the spend rate, which rises to $4.80 an hour and falls to $4.65 when Lint leaves; a legend under the jobs keys queued, starting and running. Below, History, set to 30d, lists runs and jobs with their result, pipeline, repository, cost, start and length: a CI run that passed with Healed beside it, a CLI job, E2E, Bench, and a CI run that failed, under Spend in this window, $41.25.

Running now shows the jobs running, starting or held at this moment and the spend rate in dollars an hour; History lists what ran in the window. Spend in this window counts only bills that have landed.

The **Runs** page is in the dashboard sidebar. It holds two panels, **Running now** and **History**, and from their rows it leads to a job's detail beside the list, a run's page and a job's page.

Every row is something Latchkey ran, read from its own records. A GitHub Actions job is on the page only when Latchkey served it on its runners: it is one **Latchkey on GH** row for that job, never the GitHub run around it, and it opens nothing, because Latchkey holds no page of its own for it.

## The title bar

- **Export CSV** saves the history as you have narrowed it, as a CSV file (see Export the history, below).
- **Run workflow** starts a Latchkey CI [workflow file](https://latchkey.dev/documentation/workflow-files) by hand, one that declares `on: workflow_dispatch`: you pick the repository, the workflow file, the branch or tag, and its inputs.
- **Run a job** opens a drawer with the commands to install the [Latchkey CLI](https://latchkey.dev/documentation/latchkey-cli), sign in with a key that can run jobs, and run one.
- In Easy, **Filters** opens the history's filters in a popover. Pro draws them as a row above Running now.

## Running now

**Running now**, marked **Live**, lists every job of the workspace that is running, starting or held right now, the jobs of pipeline runs and CLI jobs alike, and its head counts the jobs it lists. When it lists none, it reads "No pipeline or CLI job is running now." The line above the jobs holds:

- **Runners at once**: the runners in use against your limit ("Runners at once: 3 of 40 in use"), then how many of them are still starting and how many run Latchkey on GH jobs, when there are any.
- **warm** and **parked**: the workspace's own runners standing by, a warm one counted until the one job it takes ends; **held**: the jobs still in line for a runner, such as at the workspace's limit on runners at once or its spend limit.
- The spend rate, at list rates, of the jobs started on your runners and the cold starts still booting, Latchkey on GH jobs included, in dollars an hour.

Under it, each job is a row on one time axis: a dot and its label (a run's pipeline and job, or **CLI job** and its command), a **Starting** or **Held** chip while it waits, and a bar from when it entered the queue: queued until it is handed to a runner, starting until it starts, then running. The legend keys queued and running, and starting whenever a bar draws it. A held job also gets a line under the axis with the reason it waits, when Latchkey names one.

Each row opens its job's own page. Nothing is cancelled from Running now: a CLI job is cancelled on its own page, and a run on its row in History or on its own page. **View fleet** opens the [Runners](https://latchkey.dev/documentation/runners-dashboard) page. Past 100 jobs, the panel shows the first 100 and says so.

## History

**History** lists the runs in the window and the jobs that finished in it, one row each, newest first; press **Started** to turn the order over. It pages 25 rows at a time, with the range under the table ("1 to 25 of 140 runs and jobs"). The window sits in the history's tools: **7d**, **30d** (the default) and **90d**, plus **1d** and **Custom** in Pro, where Custom picks a start and its time up to 90 days back.

Beside the window, the search field ("Pipeline, job, sha or ref") narrows the rows, and **Spend in this window** is what the whole window was billed, whatever the filters or the page on screen. Under the table, **By key** and **By batch** break that spend down by the API key and the batch that sent the work: the three largest by name, the rest counted on one line.

### Filters

In Pro the filters sit in a row above Running now, a chip for each one set, with **Clear filters** at its end; in Easy they open from **Filters** in the title bar. Latchkey applies them to the whole window, so every page of the history is narrowed, not only the one on screen.

- **All runs and jobs** shows every kind of row; pick **Pipelines**, **CLI jobs** or **Latchkey on GH** to show one kind. The kind shown is not a filter: it gets no chip, and **Clear filters** keeps it.
- **Runner** picks a runner size, and shows CLI jobs and Latchkey on GH jobs only.
- **Repository** and **Pipeline** each take several picks, and Pipeline offers **No pipeline** for runs with no workflow file to run. Either one leaves out CLI jobs, which belong to no repository, and a Pipeline pick leaves out Latchkey on GH jobs too.
- **Branch** picks a branch the window's runs were on, and shows runs only.
- **Triggered by** lists the **People** who started runs and the **API keys** that sent CLI jobs (**not recorded** where a job's key is not named). A person shows runs only, and a key CLI jobs only.
- **Result** picks one result: Failed, Passed, Running, Stopped, Cancelled, Timed out, Action needed, Not run, Out of date or No result. Running and Not run show runs only, and Stopped leaves out Latchkey on GH jobs.

### Rows

| Column | What it shows |
| --- | --- |
| Result | The result, with **Healed** beside a pass that self-heal repaired. |
| Pipeline | A run's pipeline, **CLI job** with its command under it, or a Latchkey on GH job's workflow. In Pro a run carries its **Latchkey CI** tag, a Latchkey on GH job carries its tag with the job under it, and a run's second line gives its failure sentence, or says it was held, replaced or stopped. |
| Repository | A column in Pro from 1,280 px wide while no job detail is open; otherwise the repository sits under the name. |
| Runner | A job's runner size, from 1,280 px wide. |
| Cost | What it was billed, **free** where your free minutes covered it, or a figure **so far** at list rate until the bill lands. |
| Commit, Ref and Event | In Pro, a run's commit, its branch, tag or pull request, and what started it, from 1,920 px wide while no job detail is open. |
| Started and Took | When it started, and how long it took. |

A run row ends with at most one action, by the run's state: **Cancel run** while it is going, which asks first; **Re-run**, for the jobs that did not pass, once it ended short of a pass, unless it reads Not run or is a preflight; **Approve** on a held pull request from a fork, which opens the run page to approve the commit; **Newer run** on a run a newer one replaced; **Open billing** on a run billing stopped; and **Docs** on a run that found no workflow file. While a job detail sits beside the table, the rows show no action.

### Export the history

**Export CSV** in the title bar and the download icon in the history's tools (named **Download CSV**) save the same file: the rows the window, the filters, the search and the order keep, not only the page on screen, named for the days it covers (`latchkey-history-2026-10-01-to-2026-10-31.csv`). Its columns are Kind, Result, Pipeline or job, Repository, Runner, Cost (USD), Cost so far (USD), Commit, Ref, Event, Triggered by, Started (UTC), Took (seconds) and Id. A file holds at most 1,000 rows; when it cannot hold every row, the history says how many it holds ("The file holds the first 1,000 of 1,240 rows. Narrow the window or the filters to export the rest.").

## The job detail beside the list

Pick a run row or a CLI job row and a job opens beside the history: the CLI job itself, or a run's first failed job, or else its newest; a run that holds no job says "No jobs". From 1,280 px wide it sits beside the table, and below that under it. **Escape** or its close control takes you back to the row.

Its head names a CLI job and its result, or a run's pipeline and the run's result, with the job it shows in the trail above. Then **This job**: Result, Started, Took and **Queue to start**, a run job's Cost, a CLI job's Command and Budget, and in Pro the Runner and **Served by** (warm, parked or cold start). Under them come the job's ids, the time before its first step, and its log. Its foot holds **Open the run** for a run's job, **Download log**, which saves the log as **Raw** shows it once the whole log is read, as `<job id>.log`, and **Open job page**. On a job whose own command failed, **Hand to agent** builds a prompt to paste into your coding agent, which reads the failure through the [Latchkey MCP server](https://latchkey.dev/documentation/connect-your-ai-agent).

## The run page

A run's page ("How this run was served, where its time went, and its jobs.") opens from **Open the run**, from a job page's trail, and from the Latchkey checks on your code host. Its header holds the result, the pipeline (in Pro with its workflow file), the ref, the commit and the repository, then **Triggered by**, **Event**, a manual run's **Inputs**, **Started**, **Took** and **Cost**, over the **Run id**. Once a run has a second attempt the header counts it ("Attempt 2 of 2"), and an earlier attempt's page says it is one.

Its title bar holds one action: **Re-run jobs that did not pass** once the run ended short of a pass, unless it reads Not run, is a preflight or a newer run replaced it, **Cancel run** while it is going ("Cancel this run? Every job in it that has not finished is cancelled."), or **Approve this commit** on a held pull request from a fork.

**Jobs** draws the run's jobs as tiles, in columns by what each needs, between the run's checks; a line from one job to another means the second needs the first. A tile gives the job's result and its line, and a matrix job's tile counts its legs by result. Press a tile to open the job in a section of its own, headed by its name and **Open the job page**, with its facts, **Services** when the job started services, and the log. A matrix job's section is headed by **Open the leg grid** instead, which the matrix job's tile also carries, and lists the job's legs; press one to open that leg's facts, Services and log below the list, with **Open the job page** over its facts.

Above the jobs, each environment the run's jobs name gets an **Approval for** panel. While the run waits, an owner or admin approves or rejects it there; afterwards the panel says who decided and when, or that the environment needed no approval (see [Workflow files](https://latchkey.dev/documentation/workflow-files)). Below the jobs, **Artifacts** lists what the attempt's jobs uploaded, each with its size, the job that uploaded it, when it expires, and **Download**.

## The job page

A job's own page ("How this job was served, where its time went, and its log.") holds This job, **Services** when the job started services, and the log, and a run's job leads back to its run through the trail in the title bar. The title bar holds **Hand to agent** on a job whose own command failed, and **Cancel job** on a CLI job that has not finished ("Cancel this job? A cancelled job cannot be resumed.").

## The leg grid

**Open the leg grid** shows a matrix job's legs ("The legs of this job and how each ended."). A strip gives the **Legs**, the **Failed**, the **Median** and the **Slowest**. The grid lays the legs out on two of the job's axes, chosen under **Rows** and **Columns** (a job of one axis has Rows alone), as **Chips** or **Dots**, and in Chips a leg Latchkey flags as slow carries a caret: "over 1.5x the median". A job of three axes draws one grid for each value of the third. The failed legs and the slowest passed leg sit beside the grid, each with the way to its own page, and a failed leg whose own command failed offers **Hand to agent**.

## The log

A job's log is split by its steps, each with its status, and lines outside every step sit under **Outside the steps**. **Search the log** finds a term and steps through its matches, **Raw** shows the log as plain text, and while the job runs, **Follow** keeps its newest line in view. Logs are kept for 7 days. A step Latchkey healed carries **Healed**, with **What Latchkey did** and **Open the heal**; see [Self-healing](https://latchkey.dev/documentation/self-healing).

### Why is a GitHub Actions run not on the Runs page?

The page lists only what Latchkey ran. A GitHub Actions job Latchkey served on its runners is a **Latchkey on GH** row in History once it finishes; the rest of that GitHub run, and any run with no job Latchkey served, is not on the page.

### Why does a cost read "so far"?

Until a run's bill lands, its Cost is each job's own minutes at its size's list rate, not your invoice. The bill takes its place once it lands, and **Spend in this window** counts only bills that have landed. Free minutes used are shown on [Runners](https://latchkey.dev/documentation/runners-dashboard).

### Where do I cancel a job or a run?

A CLI job on its own page, with **Cancel job** in the title bar. A run on its row in History or on its run page, with **Cancel run**, which cancels every job in it that has not finished. Running now opens a job's page and cancels nothing itself.

---

Latchkey runs CI/CD that repairs its own failures. Agent entry points: https://latchkey.dev/agent.txt, https://latchkey.dev/openapi.json, https://latchkey.dev/llms.txt