The Reflog: week ending August 20

Vex is built in the open, on itself. Every change in this post was reviewed and landed through Vex, by the same merge queue and the same change pages the post describes.

This week shipped three CLI releases, 1.9.0 through 1.11.0. The common thread was not another command. It was removing the detective work around agent-led engineering: setup should say what it configured, a Change should retain the context that produced it, landing should enforce the checks a team already trusts, and an error should leave the next move obvious.

One setup for the machine, the repository, and the agent

vex setup is now the front door for configuring Vex agent tooling. Run it inside a Vex checkout and it installs shared skills for the machine, project skills for the repository, and transcript capture for the work produced there. Global skills live once in ~/.agents/skills; project skills live in .agents/skills, where every agent working in the repository can receive the same operating knowledge.

The target model got simpler too. Pi and other clients that support the Agent Skills standard share a generic target, Windsurf follows Devin, and MCP is an explicit choice with --with-mcp rather than a side effect of setup. The result is one command that can prepare a human’s machine and leave a repository ready for whichever coding agent opens it next.

The CLI started answering the question behind the command

A coding agent should not need a second command, a Python snippet, and a guess to understand the first command’s answer. We audited real agent transcripts and fixed the places where Vex already knew the answer but failed to say it.

vex whoami now leads with the person, organization, repository, and API endpoint instead of burying them beneath an account-policy dump.
Generated resource commands such as vex app, vex runtime, and vex artifact now list their real actions and required identifiers in --help.
--json works everywhere --format json works, including vex status and Change commands, so agents no longer fall back to parsing prose after guessing the obvious flag.
vex change show names the JJ change, target, patchset, and check state it already fetched. A raw change id printed by the API can now be pasted straight back into a revset.
Submit preflight names the review each local Change will update, orders a dependent chain base-first, says the Changes are submitted together, and prints the file count before anything uploads. vex submit --dry-run now really stops there.
vex change list defaults to a real 25-item server page, accepts --limit, and says when results were left out instead of presenting a truncated list as complete.
vex describe, commit, split, and squash fail immediately when a non-interactive caller forgot -m; they no longer open an editor into a pipe and wait forever.
Hints inherited from Jujutsu now tell a Vex user to run vex, not a stock jj binary that cannot open the repository.

The same rule reached production diagnostics. vex deploy logs now distinguishes an unknown app, the wrong allocation, a Vex id where a Nomad id was expected, a truncated allocation id, expired logs, and an invalid task name. A blank successful stream also says what answered and how many bytes it returned. Evidence collection can fail for six different reasons; flattening all six into 404 or 502 was making agents replace proof with inference.

Tours now carry the code and the conversation

Tours moved from a generated artifact into the Change itself. A ready Tour has its own tab, and each step renders the exact diff hunk it explains inline. You can follow the story of a change without bouncing between a summary and the file diff.

The evidence model underneath it became useful at the same time. A Tour can cite the repository code behind a claim, with the cited revision and line range frozen into its input manifest. It can also read the human-and-agent conversation attached to the Change: user and assistant messages provide the request, constraints, and decisions that the diff alone cannot recover. Tool traffic stays out, transcript text is read from the redacted derived index, and the prompt treats recorded intent as context—not proof that overrides the code.

This was also the week Tours survived contact with real runs. Detached workspaces clone lazily, prompts stay bounded, temporary model-stream failures retry, validation errors reach the model in actionable form, and an inline hunk is served as the complete one-file patch the diff renderer expects. Earlier runs could generate good material and still fail before publication; the whole path from source evidence to a rendered Tour now has a chance to finish.

GitHub checks became Vex landing gates

A required GitHub check could already appear on a projected Change, but appearing was not the same as gating. For a Vex-primary repository, GitHub-owned required checks now block both the merge queue and direct Land until they pass on the projection’s current head SHA.

Never-reported checks appear as expected rather than disappearing. If Vex cannot prove the current GitHub policy from a fresh snapshot, landing waits and the uncertainty cannot be overridden. Repository settings expose the candidate checks and the policy snapshot on the same page, so the rule the queue enforces is also the rule an operator can inspect.

Two adjacent GitHub paths got more honest. Ruleset bypass now reads GitHub’s current_user_can_bypass answer instead of a field the App cannot see with read-only administration permission. Git-mode submission reads a large branch diff before it opens the database transaction, rather than holding a repository lock through a slow backend round trip. And GitHub onboarding now goes straight to the repository picker; the terminal importer remains available when the terminal is what you want.

Federated Home became easier to trust

A federated Home now shows the member history it composes, not just the commit that initialized Home. Each row keeps its owning repository, and Stats For Nerds names the composition engine behind the repository so a woven Home and a physical federation no longer look identical while behaving differently.

Clone reliability closed two sharp edges: member repositories containing Git submodule metadata are accepted, and empty files materialize instead of asking the object store for bytes Git and JJ represent implicitly. Hosted agents receive a manifest-bound Home view credential for the same path rather than a raw repository token.

The surrounding lifecycle tightened up as well. Reset now detaches woven repository members before purging Home, Remove from Home treats its successful empty response as success, and Home landing proves the validated landing-scope fingerprint instead of looking for a speculative ref that federation deliberately never publishes.

History and review gained the context needed to inspect all of this. The changed-files rail keeps the monorepo’s top-level folder instead of opening at an ambiguous app/ or src/. History shows Vex and GitHub identities and links the GitHub SHA. The commit page now carries the checks, deployments, transcripts, and changed-file tree that explain how the commit arrived.

Deployments stopped loading one giant answer

The deployments workspace used to fetch one shared dashboard for seven different views, then discard most of it in React. Each view now has its own Rails-owned page contract: feed, logs, settings, architecture, details, metrics, and the surrounding workspace frame. Static Sites moved to its own route because it was never a deployment view in the first place.

The difference is concrete. Logs went from two requests, 53 queries, and 218 KB to one request, 16 queries, and 40 KB. Settings went from three requests and 83 queries to one request and 24. At the larger test shape, the metrics payload fell from 1.7 MB to 50 KB. The architecture view cut its selected-app payload by 93%, and grouped database reads replaced a scan whose cost grew with the organization’s entire deployment history.

The smaller contracts fixed behavior too: a busy app can no longer push a quieter app’s deployments out of an organization-wide hundred-row window; browser back and forward no longer leave Static Site details showing the previous site; and service, environment, location, rollout, and reachability meaning is resolved in Rails rather than rebuilt from partial arrays in the browser.

Everything else

The merge queue now preserves a missing-object refusal—with the object kind and content id—instead of spending its recovery budget retrying damage that needs restoration. Change and runtime payloads fill in patchset and service names that callers previously received as null. The CLI runner images advanced with each release, so hosted checks execute with the same source-control behavior described here.

That is the week. The Reflog runs weekly — same shape, source evidence first. If something here changed how your week went, or should have and did not, tell us.