Skip to main content
This page is a highlights reel, not a complete log. Each entry covers a release window, and it carries what a user or an operator would want to know about: new capabilities, anything that changes behaviour on upgrade, and anything that needs a decision before deploying. Plenty of good work is deliberately not here — a gap between two dates means nothing was worth your attention, not that nothing shipped.The complete, per-change record is CHANGELOG.md in the repository. That file is the release-note source of truth and every user-visible pull request is required to add to it.
featuresupdatesfixessecurity

Routines reads as an operator console

The routine page says in one line which version is published, whether a draft is waiting and which version Run will use; “In one look” answers what you get, what you provide, who does the work, what is checked, when it needs you and what it can touch. Steps group into phases from their declared dependencies, foreach blocks nest, hooks show around the run, and a recipe with more than twelve steps opens on a map with one node per group. A Files this routine runs card lists the scripts a recipe declares as a tree under the crew share, and says when a declared file is missing. A run that could not finish explains the stopping point in plain words — what was kept, what was not done, what to do next — with the raw error under Technical details. The Routines overview is built from the dashboard’s own pieces, Activity absorbs the old Work page (the /work bookmark opens the matching Activity view), and publishing a draft, editing inputs and creating a routine are popups on the routine page. The in-browser recipe editor is gone — steps, checks and agent behaviour are authored with the CLI or by the lead and arrive as drafts to publish. Editing is safe: unsaved edits survive declined reloads and navigation, Run and Plan follow your actual permissions (an explicit Run grant starts a one-time run even for a viewer), and Run again pins the version you reviewed — a changed HEAD returns 409 with a reload action instead of quietly running different code. Deleting a routine now deletes its schedules with it. See Routines and Activity.

Scheduled work goes through the durable queue

Cron-driven agent runs no longer bypass the durable work queue. A due occurrence is accepted atomically (the cursor advances and the occurrence is reserved in one commit), the shared dispatcher re-checks current permissions, serial capacity and cancellation before executing, and a restart catches overdue occurrences instead of skipping them. A run is acknowledged only after its run.started record is durable — an unavailable journal fails closed rather than letting the agent start unrecorded. Editing or re-enabling a schedule commits settings and the next due cursor together, so an old due occurrence cannot fire after a schedule change. The old direct cron executor is out of the production build. See Scheduling and Automations.
LLM proxy tokens are bound to a single agent run. A finished run’s requests are refused before credential injection — including after a sidecar restart — and the older agent-only tokens are refused outright. Drain active agent processes when deploying this protocol change; see Upgrades. HTTP routine steps with credential_ref now stop before sending if the credential cannot be resolved (store errors block with 503, a confirmed miss returns 422 — public calls should omit the reference). Synchronous peer queries return 409 when execution capacity is occupied, instead of waiting on a reservation their own parent may hold.

Provenance you can trust, evidence you can share

A routine run’s invoking crew and agent now come only from a verified identity: POST …/pipelines/{slug}/run no longer reads the invoking headers any member could stamp, and the sidecar’s internal route verifies the named agent is live and its crew belongs to the workspace. Run details show the trigger, the executed recipe version and the declared credential types from that run’s archived definition — declarations are distinguished from per-run use, and legacy invoking IDs are not dressed up as verified ones. Routine and agent run details offer a Run evidence card: a bounded, previewable copy of run references and recorded activity, safe to share, with missing journal records shown as unavailable rather than as proof nothing ran. Issue run rows show assignment IDs separately, and new routine tool events carry their run ID for accurate correlation. Routine reports (CLI) show a failed step as failed even when its final journal event is missing. See Activity and Troubleshooting.

A Keeper approval now grants what was approved

Resolving an escalation as ALLOW used to be a dead end — the agent had no route to learn the outcome and a retry was judged afresh, so an approved production credential could never execute. The agent can now poll GET /keeper/request/{id} on its sidecar and present the approved request id on the retry. The approval binds to the same agent, credential and request type (and the identical command for /execute), is single-use, expires after 15 minutes and is spent before execution — approvals cannot chain. The sampled behaviour watchdog also stopped discarding soft verdicts: WARN and ESCALATE samples now fan out to the inbox and operator review exactly like the synchronous review path. Separately, the L4 credential tier’s risk floor now sits at the default DENY-notify threshold, so an L4 credential-request DENY always reaches someone. See Keeper and Keeper reviews panel.

Three new ways to pay for models

Credentials can connect OpenCode Go and OpenCode Zen as separate encrypted API-key accounts (setup explains Go subscription limits and Zen balance overage), and a Z.AI GLM Coding Plan subscription with its own account, sidecar route and zai-coding-plan/ model selection — kept strictly separate from metered Z.AI credit, with quota never inferred from token counts. OpenAI gains GPT-5.6 Luna, including on Codex. Testing a stored Codex subscription login no longer sends its OAuth credential to an API-key probe or reports the resulting 403 as an invalid login. Credential details now explain the caller’s effective actions (role, capability, policy and scope gates — the same answers as crewship credential access and routine access), link the routines that declare the credential’s type and show whether those routines would select it (crewship credential dependents), and a rotated credential’s grace window is actually consumed: after a 401 on the new value the sidecar replays once with the previous value while the rotation is ACTIVE, and records the fallback in the journal. Routine credential lookup honors every live crew grant, not only the legacy first crew_id. See Credentials.

Backups tell the truth

A forked restore (--as-workspace / --as-crew) re-mints every capability token it carries — invitation links, port exposures, pipeline webhooks, page public links and page webhooks — so no secret that worked against the source works against the fork; invitations stay usable and the other capabilities arrive revoked, reported per table. Forks also keep their inbox and feedback rows instead of silently dropping them. A workspace export no longer fails on a stopped crew container, no longer resumes a container it did not pause, and names a DB-rows-only export as incomplete instead of presenting it as complete. See Backup.

Updates

  • CLI: the routines surface the UI had — routine calendar, routine executions, routine artifacts (with --download), routine run --fire-at/--pinned-version/--async (understands the 202 IN_PROGRESS receipt; --wait follows it) and routine save --trigger-inputs — plus routine webhooks --ingress-profile crewship|github and routine webhooks fire, a signed test delivery with the receipt printed back.
  • CLI: memory inventory --agent|--crew lists the knowledge documents the server actually reads; run insights --agent/--crew scope the fleet aggregate; issue list --counts; page project panel-history --publication; workspace update --pages-theme; work list --agent accepts a slug (an unknown slug is refused with suggestions, not an empty page).
  • Dashboard “Needs your attention” counts are exact — GET /api/v1/inbox returns active_by_kind and the dashboard counts from it instead of the inbox’s 100-row window; durations over an hour roll over to hours; colourless crews rotate the chart palette.
  • The nightly gate now fails on WCAG regressions — the axe wcag2a/wcag2aa scan replaced an unread drift report, and contrast regressions across the dashboard, crews, routines, credentials, settings, admin and chat surfaces are fixed.
  • Routine inputs and recovery rules are visible before starting work — accepted types and ranges on run forms, configured checks and failure handling in recipe details, retained evidence and duration/attempt diagnostics on runs.
  • Newly extracted user-model facts keep their source evidence — quote, message, source type and time stored beside the model file, surfaced with --provenance, and purged by every delete path.
  • The published OpenAPI document names the fields the rows actually carry — client_review_required on issue rows, optional assignee_slug, code_links, execution projections, agents’ ask_forms and suggested_prompts — pinned by a schema-keys contract test.
  • Ask about this Page opens an unsent agent chat draft; the reference survives a refused or disconnected send and is consumed only when the message is saved.

Fixes

  • A detached still-running exec no longer reads as success. When the agent CLI’s stream ends while the process lives on, the run is monitored until it truly terminates and resolves with its real exit code; an unconfirmed stop holds the agent’s run slot (ErrAgentDetachedBusy) until the runtime is confirmed gone — a stop attempt is not a stop confirmation.
  • Agentless routine runs settle SUCCEEDED, not FAILED — a run with no agent step had nobody to report an outcome, so every clean completion was recorded as a failure and success-keyed consumers read zero.
  • Confirmed webhook stops appear as cancelled in run history — captured usage survives settlement retries, and only the dispatcher’s confirmed outcome can finish a work-owned run; a retried history write never reruns the agent.
  • Pending guaranteed-memory writes are reconciled at boot, before the server accepts requests; startup fails rather than admitting a second writer over an unresolved file.
  • Webhook delivery receipts receive their documented retention sweep on boot and daily; a non-terminal work item keeps its receipt and payload regardless of age.
  • Routine approval waiting displays as a waiting status, not a red failure alert — actual failures keep their diagnostics.
  • Routine Edit again exposes approval questions and named decision actions, including approvals in nested loops and hooks; changes stay drafts until publication.
  • Routine step details again offer Test with captured run data — folded transforms and map selection reach the same testing surface.
  • Agents return to online after simultaneous detached-run completions — the last-hold decision retires completed peers atomically.
  • Reassigning a previously removed provider key works without a manual runtime restart; sidecar reuse checks live credential counts, and provider logins survive the periodic credential check.
  • Z.AI Coding Plan usage is labelled as subscription usage — zero per-call prices are no longer presented as precise monetary estimates.
  • Solo agents report model usage and observe credential revocation — sidecar IPC is initialised for non-lead agents with no peers.
featuresupdatesfixessecurity

Pages: folders, one editor, and applications you review before they go live

Pages can be grouped into crew-owned folders with an icon and a colour, and a folder can be shared — with a user, a crew or the whole workspace, as can view or can edit — so whatever is in the folder right now is shared with it: filing a page shares it, taking it out unshares it, and a page’s own grants only ever add. The Pages list is grouped by owner (Mine, your crews, other crews, owned by others) and every row says how you reach the page; crewship page list prints that as REACH, and crewship page access tells you who reaches a page and by which path. A page has its own icon and colour, stored on the row rather than in its document, so a re-applied document or a rollback leaves it alone. Edit now takes over the page the way an issue opens — a header card, then Content, Data & actions and History with Properties and Access beside them — instead of a rail of four settings sections, and it asks about unsaved work whichever link you leave by. A page with a custom application gets a review screen: what an agent changed, side by side with what is live, and a publication that attests to exactly what it showed you. See Pages, A page’s own icon and colour and Pages applications.
Publishing a Page application now has to say what was reviewed. POST /api/v1/pages/{slug}/project/publish requires expected_definition_digest and expected_routine_digests and answers 409 with a named conflict when the live definition or a routine moved after the review; a script that published blind must read the review endpoint first. A Page write grant alone no longer permits whole-document reads or replacements — a draft, an archived definition or an export that would reveal a panel hidden from the caller is refused; partial readers review source through the endpoints that omit the definition, and a save cannot silently drop a withheld panel. Management endpoints answer the same not-found for a hidden page and a missing one.

Routines: one workspace, a calendar, and edits that cannot break a plan

A routine opens on what it does, how it went last time and what to check before you run it, with History, Versions and Plan beside — a historical run keeps the exact recipe it executed, its retries and its immutable outputs, and Run again reviews those inputs without touching the head. The Calendar (Day / 3 days / Week / Month / Year) shows planned and past starts and schedules from a click on a date or an hour; a save can carry a one-time trigger.kind: "once" with a fire_at. Prepared start-form answers — choice, text, number, boolean, structured — are declared on the recipe and validated on the server before anything is enqueued. Authoring is one recipe document with durable drafts, per-step Test with explicit samples, and a full-page editor that protects unsaved work across navigation. Routine webhook receipts can be read and they expire (crewship routine webhooks receipts list|get), and a sender retrying a delivery Crewship already holds gets its receipt back even while the endpoint is throttled. A run whose caller goes away is recorded as cancelled, not failed; a start you schedule for later runs the recipe you scheduled; and an agentless routine’s clean completion settles SUCCEEDED instead of FAILED · no outcome reported. See Routines and the CLI.
Publish requires a change review and a confirmation, and a routine’s recipe can no longer change out from under a live plan by any door: routine save, the agent save, an import, a manifest apply and rollback all refuse a recipe an enabled plan’s stored preset can no longer satisfy, inside the same transaction, so a refusal leaves the original in place. A plan can no longer be saved with inputs its routine would reject — an unanswered required question, a choice outside the options — and editing a plan’s target re-checks its inputs against the recipe it will actually run.

Work that survives a crash, and a stop that means stopped

An accepted agent webhook is recorded together with the work it produces in one transaction, so a process that dies before answering leaves the work queued and the sender’s resend finds the same work rather than making a second; a delivery ledger keeps even the deliveries a filter ignored, and one dispatcher owns execution, claiming a delivery and recording where its runtime will be before creating it, so a restart cannot run a webhook twice. Every agent run has its own runtime identity — session, environment, script, FIFO and signal channel are per run, so a second run of one agent no longer kills the first. Work held on a staged agent waits for the person instead of failing. A cancel that arrives before the agent process exists is answered by protocol, and an unconfirmed process is never called stopped; Stop on an agent now waits for the runtime to confirm. GitHub and Standard Webhooks signatures are verified, with GitHub’s replay gap closed. Agent memory tools write through the host’s revision-checked ledger, and a write that cannot be revision-checked is refused rather than performed and labelled. See Work items, Webhooks and Agent memory.
The database now commits with synchronous=FULL — work answered 202 has to survive a power cut. Measured cost is about 21 ms of fsync per acceptance commit. Memory MCP writes require the host ledger: until the bridge is available to a run, memory.write and memory.append_daily return an error instead of silently writing through the legacy path. An interrupted dispatch that cannot be confirmed stopped stays in reconciliation for an operator — crewship work resolve records the investigated outcome with a reason and an explicit runtime-stop attestation.

Incoming webhooks, and messages between people

Integrations gained incoming webhook configuration for routines, agents and Page panels, on the same explorer, overview and endpoint detail as every other integration; a routine webhook can select a GitHub pull-request signature profile with content-based replay protection. See Integrations.Chat is one column for everything you can talk in: agent sessions, direct messages with a colleague, private groups and workspace channels — a mentioned agent answers in a channel, and a DM or a group can be continued into a new room without exposing its history. Personal notification sounds (five tones, separate Chat and Inbox choices, Do not disturb) live under Settings, and an image or a PDF opened from the Files panel previews in place. crewship chat room manages the rooms; crewship seed --with-team-chat seeds six colleagues with real roles and messages. See People, groups and channels.

Crews, credentials and issues

A crew or an agent opens on Overview / Team / Work / Memory — the knowledge it has retained by scope, and what agents have saved about you with a Forget on each — and creating one requires an explicit provider choice, with the matching runner installed automatically. Provider logins (Codex and Gemini device sign-in, crewship credential login, server-held refresh) join API keys; provider pools define explicit account sets with priorities (credential pool, and an admin screen), though runtime binding is still to come; the guided credential flows separate Add secret from Add provider. Codex works again through the sidecar: the OPENAI_BASE_URL route the binary no longer reads is replaced by a per-run model_provider, MCP notifications are acknowledged with 202, and two OpenAI hosts a Codex run needs are on the default allowlist. Issues can move between people and agents with explicit handoff notes and a current worker, crewship issue review-policy requires human acceptance before an issue counts as done, and an issue that ever ran can be deleted. See First crew, Provider logins and Issue detail.
Provider account administration is owner/admin only, in the API and the console alike — legacy provider API keys and CLI logins included; other roles see only the provider brand. OWNER/ADMIN memberships without explicit capability overrides now receive credentials:reveal (existing explicit sets, revocations included, stay authoritative), and a revealed value disappears after 30 seconds. Agent peer-profile endpoints answer only the signed-in user’s own profile, administrators included. Imported Gemini refresh needs a server-side OAuth client that matches the grant; the bundled client credentials are gone. And with Keeper off, an unclassified credential type is no longer injected into the agent environment — a legacy row that relied on the fallback-as-SECRET treatment stops working and the server logs which credpolicy row is missing.

The phone is a first-class way to run Crewship

A tab bar (Dashboard, Inbox, Chat, More) on the bottom edge, “Add to Home Screen” with its own icon, Back that closes an open drawer instead of leaving the page, explorer drawers that open full height, tables that scroll instead of clipping, a search field that no longer zooms the page on iOS, and motion that respects the system’s reduced-motion setting. The PR gate now runs at a phone width. The dashboard fits one screen: results and crews are rows, the run summary is one strip, the chart is shorter.

Updates

  • The two daily memory sweeps can be run now — crewship admin memory sync user-model|peer-cards [--all] [--dry-run].
  • An agent reports whether its credential actually authenticates its model — crewship agent credential-readiness <agent> (ready / missing / unknown), computed by the runtime’s own delivery rules.
  • Routine waits take typed decision forms on the web, in the inbox and from the CLI, and a rejection or an approved answer can be recovered.
  • The Docker image is verified before it is promoted — boot, health and the embedded UI, per platform by its immutable digest, with the runtime’s security packages refreshed at publication. dev.sh status says when a workstation serves old code.
  • -f yaml prints the same keys as -f json on every command, and crewship work get -f yaml no longer panics.
  • Building from source needs Go 1.27 — the go.mod floor moved from 1.26 because a dependency required it.

Fixes

  • A GDPR erasure now unnames the subject on every workspace-scoped table (~40 columns): credentials they created pass to a custodian with a REATTRIBUTED audit event, grants and invitations are revoked, history columns are anonymised.
  • An agent turn-limit failure no longer appears as a generic process exit; the cause and the turn count survive a nonzero exit.
  • docker rmi crewship-cache:* no longer triggers eighty provisions a second — a cache hit is confirmed against the daemon, and a rebuild loop stops after three attempts with a clear error.
  • An agent re-saving a routine without a description no longer erases it; step environments and arguments are bounded before allocation.
  • The approval gate’s queue row no longer carries the raw prompt — a scrubbed preview sits in payload.review, and because the gate’s arguments are also its reward-tuning fingerprint, auto-tuning can finally reach its quorum for agent_run.
  • Five BackupTables entries no table backs are gone, each a silent no-op on every restore; a schema guard now checks the list both ways.
  • Two OSV advisories that turned main red overnight (sharp’s bundled libheif, grpc) are cleared.
featuresupdatesfixessecurity

The answer to a credential ask is a grant, not a value

An agent that needs a credential it does not have raises an ask — a name, a type, a tier and a purpose, never a value. That ask now stages a handle-only credential in the vault, and the person who answers it supplies the value through the inbox card or crewship escalation supply <id>, which reads from stdin and has no flag for it. The agent is told the credential’s name and that its use is keeper_execute; the value never enters its stdout, its transcript or its model context, and a handle-only credential is never delivered as an environment variable or a file, Keeper on or off. Before this, the typed secret was encrypted into the escalation row and handed back to the agent in plaintext. The Keeper now also judges the ask itself before a human sees it — an off-task or prompt-injected agent can no longer spam credential requests at the operator — and a credential supplied on a running server is usable at once, not after the next restart. See Asking a human for a credential, Handle-only credentials and Keeper.
A CREDENTIAL escalation takes no resolution text. /resolve answers 400 to any resolution on one, approve or reject, and crewship escalation resolve --resolution is refused for it; a script that used to answer an ask by typing the secret into the resolution must call crewship escalation supply <id> instead. An agent whose prompt still expects the value in the wait response receives the name and the use instead — the shipped agent prompt is updated, a custom one needs the same edit. Historical answered asks now read [credential submitted] everywhere; the ciphertext is gone from the database.With Keeper on, an ask the judge denies is never staged and never reaches a person — the agent gets the reason and the journal records it. With Keeper off, every ask reaches a human as before.

Issues and routines: the reliability track landed

Every issue now has one event log and a durable session per (issue, agent): a mention on a busy agent is acknowledged before any model call, queued behind the live run instead of racing a second one, and folded into the next turn; ten concurrent deliveries of the same event produce exactly one run. A run holds a lease its owner renews, so a killed process’s runs recover in seconds rather than at the next restart, and never steal a live replica’s run. An agent that wakes on an issue gets a bounded context pack and can read the comment thread it was woken for. Stop now actually stops — the next step, a run still queued, a run a mention started on an issue that was never started — and crewship issue stop --hard ends the run’s own process inside the shared container without touching a sibling agent’s. An issue’s owner and its delegate are two columns, so delegating to an agent no longer erases the person.On the routine side, a routine, its version and its trigger commit in one transaction — a bad cron expression rolls the whole save back — and a save can create the trigger as a draft that one MANAGER+ approval turns on. The new reliability editor exposes every schedule field the backend already carried (catch-up policy, wake gate, breaker threshold, version pin) with a DST-safe preview of the next five fire times, and a webhook can be edited in place without rotating its URL. The inbox learned the attention contract: producers describing the same condition merge into one card, receipts name the version they decided on, a quiet-runs digest replaces the silence, and a run_needs_human card offers Answer, Take over and Dismiss on the web and as crewship inbox act — answering resumes the run from its checkpoint. The issues board moves without a refresh, a parent waits for its children, and the service levels the PRD promised — delivery latency, continuation, duplication, comprehension, fire punctuality — are real percentile series on /metrics. See Issue detail, Routines, Inbox and Prometheus metrics.
DONE is the only word for finished on an issue; COMPLETED is retired. A migration rewrites every COMPLETED mission row to DONE, and the PATCH endpoint writes DONE for both mission types. A legacy {"status":"COMPLETED"} request is still accepted and normalised. Anything that filters missions on COMPLETED — a saved view, a script, a report — now finds nothing. assignments.status and pipeline_runs.status are untouched.
Three doors now refuse what they used to accept. crewship issue start answers 400 on an issue with no delegate, or whose delegate is not a live agent. Moving a parent to DONE or REVIEW while a sub-issue is live answers 409 unless you pass --force / ?force=true, and the override is recorded. And a waitpoint can no longer be decided by an agent: a peer’s “GO” — a crew token, a sidecar tool, any agent-facing route — answers 403 with waitpoint_decider_not_allowed, the waitpoint stays pending for a person, and the attempt lands in the audit log. An automation that had an agent approve waitpoints stops working by design; the card says who can act.

The web app reads as a product

First-run setup is a wizard with real toolchain marks, a checklist, and a Guide that can see the workspace and give a crew a face. One model catalog (config/models.json) feeds the binary and every web picker — the Go side no longer offers models the web never did. The dashboard answers in order: what needs a human, then what is running, then the fleet. The inbox reads as decisions and is never blank; chat says who you are talking to; the crews screen reports the real fleet size and opens each crew with a “Needs you” strip whose rows carry the one action that resolves them. Issues, routines, activity and the journal keep their selection in the URL, so a drill-down can be linked and Back does what it says; /journal gets saved views and a real query contract. Settings gained a screen for the lifecycle-hook registry, and the New agent dialog can create a workspace-wide agent — only a Lead still needs a crew. Every list endpoint describes its window (X-Total-Count, X-Limit, X-Offset, ?q=) and every CLI list takes --limit/--offset and ends with what page it showed. See Onboarding and Crew journal.
GET /agents hides the setup crew’s Guide unless include_setup=1 (crewship agent list --include-setup). A script that counted agents, or looked the Guide up by slug on that list, needs the flag. The agent role retired in April is now refused everywhere it was still promised — the create-agent dialog, crewship agent create, crewship apply and crew suggest — rather than planned and then rejected by the server; an agent is AGENT or LEAD.

What the journal keeps, and who may read what

The journal no longer stores the prompt text of a run or the body of a message you sent. exec.command carries the argv’s shape with the prompt elements named and replaced, and chat.user_message records a length, not a preview — a token pasted at the start of a message used to sit inside the 240-character preview, in a hash-chained table that erasure requests skip. The same table now receives the agent’s raw output only through the credential scrubber, and an escalation’s text reaches it redacted and capped, as the inbox copy already was. The crew-scoped file download no longer serves the generated MCP credential files the agent door refuses; the MCP OAuth client binds its token to a resource and checks the issuer; the public mission-start route checks the autonomy gate the internal one always did, so a MANAGER can no longer start a gated mission by choosing the other URL. Erasing an operator model now reaches every crew it was ever written to. See Crew journal, Harbormaster and Autonomy and self-learning.
Rows the journal wrote before this release keep what they hold. The chain is append-only and cannot be rewritten, so the change stops the leak going forward; it does not scrub history. If a secret was pasted into agent chat before the upgrade, rotate it.Decided approval-queue rows now age out after 90 days. approvals_queue was kept forever, rode into every backup, and its read endpoints answered any workspace member; it now follows crewship workspace update --approvals-retention-days (0 keeps forever), pending rows and autonomy gates are never swept, GDPR erasure reaches it, and reads are role-gated.A crew’s shared credential store now serves an agent only what that agent was granted. One sidecar serves a whole crew, and its store used to hand a model call whichever credential a round-robin landed on — with an OpenAI-compatible credential, that decided where the prompt went. An agent that was silently borrowing a sibling’s credential now gets “no credential”; grant it one.

Updates

  • crewship seed ships three real demo packs, and seed verify proves them. A nightly CI watch over this repository’s scheduled workflows, a docs-drift audit, and a site replica delegated across four agents — each a crew with its own scripts, routines, page and issues. seed verify runs every pack end to end and checks the agents against independent probes. See Demo packs.
  • The rate card was refreshed against the providers’ published prices. gpt-5.5 bills at 10.00/45.00 per million (it was 4.00/24.00 — the long-context tier, chosen so a long call is never under-billed), gpt-5.4-nano and both Gemini 2.5 Flash rows moved up, and the Claude 5 rows are present. Ledger rows written before the refresh keep the rate they were billed at; new rows use the corrected one, so a budget that sat under its cap can now trip it. Hosted OpenAI auxiliary calls use max_completion_tokens, which the current models require. See Paymaster.
  • Backups verify completeness, not just integrity, and fork cleanly. crewship backup verify can now tell a short bundle from a whole one; a forked restore (--as-workspace / --as-crew) re-signs the journal chain it rewrote, regenerates the instance-unique columns that made a live mission vanish silently, and migrates pre-1.0 issue counters instead of dropping them. See Backup.
  • Ten lifecycle-hook events that registered but never fired now fire, and on_budget_exceeded fires once per breach rather than once per LLM call while over budget. pre_tool_call is retired for good — Crewship drives an external CLI and sees a tool call after it ran. See Hooks.
  • An automation refuses an event type nothing emits, and a webhook or automation that fails to start a run raises an inbox card after three consecutive failures, not just a log line. See Automations.
  • Inbox read state is per user. The first manager to open a role-targeted item no longer marks it read for every other manager. resolved stays shared.
  • The CLI covers more of the API. crewship auth pair mints a device code, auth profile edits your display name, feature-flag create|update, admin workspaces, admin memory-stats, routine runs-all, routine changes <run_id>, routine schedules preview|activate, routine webhooks update, agent status, agent load, system crewshipd, issue comment --mention, issue update --force, issue sessions, inbox act and escalation supply are new. Routine runs finally reach /api/v1/runs and the Runs view.
  • The wake-time prompt shows the agent its own memory budget, and a fresh agent with no credential no longer looks identical to a healthy one.
  • The security pages say what the code does. The threat model, RBAC and credentials guides, the README and keeper.mdx no longer claim more containment than exists; the 1.0 known limits are written where a reader meets them.

Fixes

  • A second run for a busy agent no longer kills the first. Two concurrent runs for one agent reused the same tmux session, and the second’s opening kill-session ended the first. A dispatch that loses the lock is queued and says why (queued_reason: crew_budget or agent_busy); a chat to a busy agent bounces with agent_busy instead of colliding.
  • Hard stop was signalling a host pid inside the container and ended nothing; it now ends the run’s own tmux session.
  • An invited member could not authenticate with the CLI at all — a NULL display name broke CLI-token auth.
  • crewship backup defaults its bundle directory under $CREWSHIP_DATA_DIR/backups when that variable is set, falling back to ~/.crewship/backups only when it is not. Several instances run by one user on one host shared a directory, and a restore could pick up another instance’s bundle by name. If you set the variable, bundles you took before are still in the old directory — pass --output or move them.
  • A routine’s step chats no longer evict your conversations from the chat column; GET /agents/{id}/chats takes ?kind=.
  • crewship routine save no longer erases a description when --description is omitted; an explicit empty value still clears it.
  • Agent avatars were never stored (the backfill omitted the workspace), crewship crew suggest --goal could never succeed, and the create-crew wizard could offer a crew it was then unable to create.
  • Reactions and feedback submitted right after a streamed reply now use the persisted message id and survive a reload; a suggestion chip clicked twice no longer sends twice; clearing a crew’s issue prefix actually clears it.
  • The Docker image builds again — the backend stage now copies every root package the binaries import, and a test fails when one is missing.
  • The issues board renders a fetch failure as an error and says when it is showing a partial page; a 403 is a named error rather than an empty board.
featuresupdatesfixes

A provider is now a credential

The sidecar’s LLM proxy routed on a hardcoded three-arm switch. It now routes on a descriptor table, and a credential carries its provider end to end — so adding a backend is a row rather than a branch. Two arrive with it: OpenRouter and OpenAI-compatible endpoints (LiteLLM, vLLM, anything serving the OpenAI wire format), both created like any other credential. crewship credential create gains --base-url for the compatible kind and --auth-token-stdin so a token never reaches the process table, and crewship provider route list shows the whole routing table with no server running. The three existing paths — /v1, /openai, /gemini — are byte-for-byte unchanged. See Credentials and Multi-provider LLM configuration.
A credential PATCH that re-interprets the stored value is now refused. An endpoint-backed credential holds a {baseURL, apiKey, headers} object; every other kind holds an opaque value. Moving a credential across that line — changing provider to or from OPENAI_COMPAT, or type between ENDPOINT_URL and API_KEY — now returns 400 unless value is sent in the same request, instead of silently re-reading bytes it was never given. A PATCH that carries a value also validates the endpoint URL for the first time, so one that used to accept a link-local or metadata address now refuses it.Two smaller edges: provider is normalised to its canonical uppercase spelling on write (a client that sends github reads back GITHUB), and several crewship credential create argument errors moved from exit 1 to exit 2. A script that branches on exit 1 needs updating.

One shell for every create surface

The twelve create dialogs that had each grown their own layout are now one kit — consistent widths, a bottom sheet on a phone, ⌘↵ to submit, and a discard guard so Esc never throws away typed input. Three things became possible from the browser for the first time: importing a crew manifest into New crew, granting per-agent tools and notification channels on New agent, and creating a label from the issue modal. The crew wizard is four steps instead of five.
New crew now pre-selects free network mode, not restricted. Only the wizard’s default selection moved — anything that creates a crew without stating a mode (a manifest, the API, a seed) still gets restricted. If you rely on operators being handed the restricted default in the UI, say so in your own onboarding, or set the crew’s network policy explicitly. See Container isolation.

Start and stop a crew on purpose

crewship crew start <crew> builds the image if needed and brings the container up, verifying it actually came up rather than assuming; crewship crew stop <crew> takes it and its sidecars down, keeping volumes and the image. Until now the remedy several error messages recommended was crewship crew provision, which only builds the image and starts nothing — so following the advice reproduced the error. Those messages now name crew start, and say what provision does and does not do. crewship apply also stops claiming success on a failed run — it now names the item that failed and everything after it that was never attempted — and gains --no-delete, which refuses any run whose plan would destroy something. See crewship crew and crewship apply.

Run a routine from a slash command

A routine can opt in to appearing as /<slug> in chat and in crewship shell, with a typed form built from the inputs it declares. A new routine.run capability lets a MEMBER invoke routines without being promoted to MANAGER. The run is synchronous and its output goes to the run records, not to the chat. See Slash commands and Routines.

Onboarding builds working things, owned by the crew they belong to

First-run setup is now a conversation with a permanent Crewship Guide crew. The important part is invisible: a routine or page the Guide builds for you is now attributed to your crew, not to the Guide — which decides whose egress policy gates it, whose container runs it, and whose roster its panels can see. See Onboarding.
Backups taken before this release may be missing rows. The backup’s workspace scope was derived by walking foreign keys without checking whether the column it landed on was nullable, and a filter on a nullable column omits every row where it is NULL. Unclaimed mission tasks, crew-owned MCP servers, human-saved page versions and several binding tables were affected — and because the walk depended on Go map order, two runs of the same binary against the same schema could omit different tables.It is fixed, but crewship backup verify cannot detect a short bundle: it checks the payload checksum, and the manifest records no per-table row counts. Treat bundles taken before this release as unverified, and take a fresh one. crewship backup restore --replace was deleting through the same faulty filter, so restoring an old bundle over a live workspace was doubly affected. See Backup.
A crew whose mise shims do not resolve will now fail to provision. mise reshim exits 0 whether or not the shims point at anything, and a dangling symlink is skipped silently by PATH lookup — so a crew pinned to terraform 1.9 could run whatever the base image shipped, with nothing logged. Provisioning now verifies the shims and fails loudly instead.Crews created before 2026-08-07 carry stale shims and do not self-heal. Expect their next provision to fail; re-provision them from a current image. Crews that declare no mise tools are unaffected. See Devcontainers.

An integration’s audience is stored, not counted

An MCP server used to be available to every agent for exactly as long as no agent was bound to it: “available to all” was inferred from a binding count of zero, so the first binding anywhere in the workspace flipped the server to opt-in and revoked it from every other agent — silently, with nothing on the integration’s page saying so. Every MCP server now carries default_access (all or bound-only) and resolution reads it. Binding an agent attaches a credential, a config override or an opt-out for that agent and changes nobody else’s access; narrowing a server is a deliberate act: crewship integration access <id-or-name> bound-only, --access on integration add / integration crew create / integration crew update, or default_access on the API. integration list gained an ACCESS column and the integration’s detail panel names its audience.
Upgrading does not move anybody’s access. The migration freezes each existing server at the audience it effectively had: servers that already carried an agent binding become bound-only, everything else becomes all. Nothing is granted and nothing is revoked at upgrade time — but from then on, only an explicit change alters who can use a server. If you were relying on the old side effect to keep a server private, it is now written down as bound-only and will stay that way.
Same pass: mcp_tool_bindings had no referential integrity, so deleting an integration stranded its per-tool toggles forever. They now follow their server, an insert naming a server that does not exist is rejected, and the rows already orphaned are swept. See Integrations and crewship integration.

Updates

  • An evaluator slot follows the key you actually have. Auxiliary slots now default to the first provider whose API key is set, instead of six slots hardcoded to Anthropic that each failed at first use on an OpenAI-only instance. See Keeper.
  • Two Keeper aux controls that did nothing now do what the console claimed. Memory consolidation reads the curator slot — it was hardwired to Ollama at boot, so an instance with an Anthropic key and no Ollama silently ran no consolidation at all while the card showed the slot healthy. And run_summary’s timeout now actually bounds the verdict call; its shipped default moves 15s → 20s so the first real deadline is not tighter than what those calls had been running under.
  • Crew template names are unique per workspace. Two workspaces can each have a backend-team template. A workspace template shadows the built-in of the same name, for that workspace only — and a built-in whose slug a user had taken can be seeded again, which it previously never could.
  • An OpenAI-compatible credential can be tested. It was the only LLM provider with no connectivity test, and it returned a green tick without dialling anything. The probe checks reachability, not authentication — it deliberately never sends the stored key, because whoever can edit the credential can also repoint its URL.
  • Pages can be published, webhooked, exported, imported and deleted from the browser. All of that was CLI-only. See Pages.

Fixes

  • A page’s public panels were silently unpublished by reading them. The public flag was not echoed on any read path, so crewship page export | crewship apply, a hand-edited page get -f json, or the editor’s own save cleared it. The published link kept resolving and rendered an empty page, and the next page publish then blamed the page for having no public panels.
  • The mission timeline’s “Restore” restored nothing and said it had. The endpoint computes a preview by design — it rewinds nothing — and the UI reported success and discarded the response, including the list of later events a real restore would have to abandon. The action is now labelled Preview restore and says what it found.
  • The Add-MCP wizard’s “Test” could not fail. It was a timer that returned success, with no failure path at any input. It is gone; connectivity is tested on the server’s row after it exists, or with crewship integration crew test.
  • One unrenderable chat message no longer takes down the page. A single bad turn used to replace the whole conversation with an error screen, discard every turn’s state, lose a half-typed draft and drop the live WebSocket. Now only that message is replaced, and it heals itself as the next token arrives.
  • Pinned memory could be read empty. pins.md and the day’s learned rules were created before they were written, so an agent reading its own rules in that window saw nothing rather than the previous contents — reproducibly, on a tick that runs every six hours. They are written atomically now.
  • Forking a mission from the timeline 404’d, and the 404 was rendered as “not yet wired to backend” — so a broken call looked like an unbuilt feature.
  • Accessibility. Page tabs are now linked to the panels they reveal and the strip is keyboard-navigable with arrow keys; crew and agent canvas tabs are a real tab set rather than buttons claiming to be one; the admin console’s content pane can be scrolled by keyboard; New routine has a Cancel button on every screen.
featuresfixes

Multi-provider LLM configuration

The three-arm provider switch is now a registry: one row per provider, read by the aux-slot builder, the Keeper validator, the console picker and the error message that tells an operator what they may type. The two hand-written HTTP clients behind it became configurable codecs, so any OpenAI-compatible backend (DeepSeek, vLLM, llama.cpp, Ollama’s /v1 shim, OpenRouter) is a config value rather than a new file. Evaluator slots now default to the first provider whose key you actually have, so an instance holding only an OPENAI_API_KEY stops demanding an Anthropic one. A trimmed models.dev snapshot ships embedded and prices 621 models across eight providers offline, as a third step in the rate lookup below the hand-verified table. Two new local commands read those tables with no server: crewship provider list and crewship model price. See Multi-provider LLM configuration and Paymaster.

Proxied agent calls start billing for real

Read this before deploying if you use budget limits. Every LLM call an agent made through the sidecar proxy has been recording zero tokens and $0 since the proxy was built. The usage parser switched on a lowercase provider name ("anthropic") while the proxy handed it an uppercase one ("ANTHROPIC"), so it never matched and every response body went unparsed.It is fixed, and the consequence lands on the first deploy: crews whose agent traffic goes through the proxy will begin posting real token counts to cost_ledger. Budget warnings and hard stops that have never fired on those crews can now fire immediately — not because anything got more expensive, but because the spend was always there and was being recorded as nothing.Before deploying, check budget_limits for any crew that runs proxied agents and confirm the ceilings were set against real usage rather than against the $0 these rows have been reporting. A limit that looked generous against zero may be below a normal day.

Fixes

  • OpenAI cached tokens were billed twice. OpenAI’s prompt_tokens includes the prompt-cache read, and the codec stored it verbatim alongside the cached count — so an 80%-cached 1500-token prompt billed 2.67× the invoice. The codec now records fresh input only, matching what the sidecar proxy path has always done. cost_ledger.input_tokens changes meaning for OpenAI-family rows and historic rows are not migrated, so a rollup spanning the change is not comparable across it. See Paymaster.
  • Long-context models were billed at their base rate. 76 catalog models publish a second rate card above a context threshold, up to 6.7× base. They are now priced at that ceiling — a deliberate over-estimate, because under-billing weakens the budget signal exactly when it matters.
fixes

Updates

  • Grandfathered crews tightened to restricted egress. Existing crews still on the legacy network_mode=free default are backfilled to restricted on upgrade, so they stop getting unrestricted outbound access. The column default itself is also flipped to restricted, so any crew created without an explicit network mode — a raw insert, a seed, a future migration — is now restricted by construction rather than defaulting open. A restricted crew still reaches all built-in LLM/CLI provider domains plus any it explicitly allowlists; if a crew genuinely needs open egress, re-open it to free (or add the domains it needs) from its network policy. See Container isolation.
featuresupdatesfixes

Slash commands and per-user capabilities

End users now get a server-driven slash palette in chat and CLI for /routine, /issue, /skill, and /credential. Each action is gated by a per-user capability, so admins can grant a single MEMBER permission to author routines or rotate credentials without promoting them to the MANAGER tier. Capabilities are managed inline from Workspace Settings → Members (with a preview diff before bulk preset changes), or via crewship workspace member capabilities. See Slash commands and RBAC.

Streamlined first-run bootstrap

The setup-token gate is gone. The /bootstrap form now takes name, email, and password — submit and you’re in. Bootstrap stays open until the first admin account exists, then returns 410; set CREWSHIP_BOOTSTRAP_WINDOW (any Go duration, e.g. 5m) to opt into a finite deploy-race window that closes that long after crewship start — for instances reachable from the internet before anyone bootstraps them. Both browser and headless (crewship init) paths hit the same endpoint and share the same gates. See Quickstart.

Disaster-recovery backup rewrite

crewship backup restore adds a --replace mode for the canonical “nuke and restore preserving original IDs” flow. The restore pipeline now discovers workspace-scoped tables at runtime, reconciles users by email so an admin with the same address on source and target doesn’t orphan FK references, and applies section-aware symlink policy so workspaces containing node_modules (or any project with relative-target symlinks) restore cleanly. See Backup and crewship backup.

Declarative apply for crews, agents, skills, integrations, and issues

crewship apply now understands five additional top-level kinds — Skill, Crew, Agent, Integration, and Issue — so a workspace can be provisioned end-to-end from a single manifest bundle. Built-in seed catalogues moved from Go literals to embedded YAML, so the same shapes round-trip through export/apply. See Manifests and crewship apply.

Mission outcomes feed crew memory

When a mission completes, its outcome and provenance now flow into crew memory automatically — agents can recall what they shipped and why on the next mission without an operator re-priming the context. See Episodic memory and Agent memory.

Workspace switcher

The sidebar workspace switcher is now real: list every workspace you belong to, switch with one click, persist the selection across reloads, and create a new workspace from the same menu. The selected workspace is honored by every component that reads it. See Onboarding.

Profiling and tracing setup

Two opt-in observability surfaces landed: a pprof endpoint for CPU/heap snapshots and a Pyroscope push exporter for continuous profiling. The OpenTelemetry service.name is now configurable via env so multiple deployments tag their traces distinctly. See Telemetry and the OTLP setup guide.

Updates

  • Destructive CLI commands prompt before acting. Six commands now ask for confirmation and accept --yes for scripted use.
  • Manifest validate catches duplicate slugs. crewship apply --dry-run now fails fast when two documents share the same metadata.slug within a kind, instead of silently overwriting on apply. See Manifest schema.
  • crewship apply gains --skip-test-gate. Routines that depend on PENDING credentials can now be applied without the pre-flight test invocation, and type: code steps surface a plan-time warning so the gap is visible before the cron fires. See crewship apply.
  • Go toolchain bumped to 1.26.3. Picks up eight stdlib CVE fixes; no API or behaviour change.
  • SQLite busy timeout raised 5s → 30s. Eliminates the spurious “Invalid email or password” login error that surfaced on moderately loaded instances after a backup restore.
  • CLI hardening pass. Security tightening across the CLI binary. See CLI overview.

Fixes

  • crewship workflow create --help no longer panics from a flag-shorthand collision with the root --format flag. See AI workflows.
  • Persona commands crashed on every invocation; now fixed.
  • CLI typo’d subcommands are rejected with a clear error instead of being silently dispatched to crewship ask.
  • crewship now / me / today now exit non-zero when every fetch fails with session_invalid, so wrapper scripts notice the missing login.
  • /metrics loopback bypass now checks the true client IP, closing a path where a misconfigured proxy could expose the endpoint externally. See Metrics.
  • Create-workspace dialog now resets when closed via Cancel, Escape, or overlay click — stale values no longer persist across reopens.
  • MCP registry page size is now capped at 100 to prevent unbounded responses.
  • Example manifest (examples/manifests/full-complete.yaml) had two invalid tool_profile values that failed validation for anyone copying it as a starter — corrected to the documented enum.
featuresupdatesfixes

Agent Evolution lands

The full Agent Evolution release rolled out across seven coordinated changes. Highlights:
  • Native memory tools. Agents now have first-class memory read/write tools wired across all MCP-capable adapters. Memory is scanned before it’s persisted and consolidated automatically — see Agent memory and Memory observability.
  • Autonomy slider + auxiliary model slot. Each crew now exposes a per-crew autonomy slider and a separate slot for an auxiliary (smaller / cheaper) model. Tune how often an operator gets pulled in, and route routine sub-tasks to a different model. See Autonomy and self-learning.
  • Keeper Phase 2. Keeper now reviews skills, evaluates per-crew behavior mode, tracks memory health, and applies negative learning from rejected actions. See Keeper and Keeper reviews panel.
  • Ephemeral agents. Hire an agent with a TTL, let it ghost when the TTL elapses, rehire if the work isn’t done — with a full audit trail of when it was active. See Ephemeral agents.
  • PERSONA + peer cards. Per-user agent personas and peer cards land alongside new GDPR primitives for user-scoped data export and deletion. See GDPR.

RBAC v2

Role-based access control gets a major overhaul:
  • Per-crew role editor inline on the crew membership table.
  • Agent owner badges on every agent card, with API exposure of the owner field.
  • Token issuance dialog now shows tier, scopes, and expiry; listing exposes the same fields. CLI bootstrap and pair-redeem tokens are now 256-bit.
  • Per-agent ownership gates on agent create, update, and delete, plus per-crew role elevation honored at create time.
  • Structured 403 responses with denial audit logging.
See RBAC.

Pipeline webhooks: signed by default

  • HMAC signature required on every webhook dispatch.
  • Signing secret auto-generated when a pipeline webhook is created — no more silent unsigned deliveries.
  • Replay protection via synthetic idempotency keys; duplicate replays are now auto-deduped.
  • Rate-limit floor and reserved-key inputs hardened on the webhook endpoint.

Updates

  • OpenAI provider now mirrors the Anthropic retry/backoff behavior — flaky upstreams get the same treatment regardless of provider. See Providers.
  • X-RateLimit-* headers are now returned on every 429 response so clients can back off intelligently.
  • CREWSHIP_FORCE_SECURE_COOKIES env override lets you force secure cookies in front of an HTTPS-terminating proxy. See Environment.
  • Sidecar hardening. The production sidecar baseline got a security pass, and the prod Docker socket is now brokered through a filtering proxy. See Container isolation.
  • Memory scanner now blocks invisible-format (Unicode Cf) codepoint evasion in addition to existing checks. See Memory observability.

Fixes

  • Keeper cross-tenant defense. Workspace context is now correctly wired onto Keeper routes — previously the defense was unreachable.
  • Sidecar memory startup. The agent memory base directory is now set even when the full-text search engine fails to initialize, so agents stay usable in degraded mode.
  • OAuth state and session IDs bumped to 256-bit randomness. See Auth.
  • Path-traversal hardening. .. segments are rejected before the router normalizes them; /_next/* directory autoindex is blocked; every ID interpolated into internal URLs is now path-escaped.
  • Permission gates. Agent files, downloads, and logs now require the read permission; nine pipeline mutating handlers are gated on per-role checks.
  • Log redaction. Raw token values are now logged as fingerprints instead of full tokens, and structured logs are routed through the Lookout redactor.
  • Payload limits. The auth credential callback body is now capped at 16 KiB to bound memory use on hostile clients.
  • Backup integrity. Table identifiers are validated before being used during foreign-key introspection. See Backup.
  • Devcontainer safety. Cumulative tar extraction is capped at 500 MB to prevent decompression-bomb scenarios. See Devcontainers.
  • ETHOS refusals no longer leak tool, directory, or sibling-agent enumeration data in error messages.
  • Orchestrator context propagation. Request context is now correctly threaded through background work spawned by handlers, including five mission-engine call sites that previously dropped it.