November 2026 status archive, page 26 of 26
Shutdown notices, recent changes and all monthly archives
These events link to today's eligible findings, not historical before-and-after claims.
Cited events
6 ADEs
Warp Factories / Ozresearch correctionfreshness recheck48 findings · 33 sources
Findings today
- Warp desktop app is offered on macOS, Windows and Linux and exposes the cloud-agent setup and conversation surface…
- The documented harness identifiers are oz, claude and codex; factory agents can use different harnesses.
- Managed-secret Codex cloud authentication bills a funded OpenAI API account, not a ChatGPT subscription; Claude Code…
- Guided browser onboarding offers automation, app-based cloud agents or programmatic agent workflows.
- oz agent run-cloud and oz agent run provide distinct managed and unmanaged execution.
- Factory and standalone agents use stdio, Streamable HTTP or SSE MCP servers.
- A direct request goes to the factory foreman.
- A spec agent defines behavior, constraints and validation criteria when planning is needed.
- Default spec approval is foreman instruction policy; merging is enforced by repository permissions and branch…
- Factories accept direct requests, integration events or Factory MCP tasks.
- External coding agents retrieve the same task through URL, source ticket, PR or branch reference.
- Spec agent produces behavior, technical constraints and validation criteria for a work item.
- Parent and child agents execute in parallel with independent conversations and run lifecycles.
- The foreman routes work to triage, spec, implement or review agents.
- A parent spawns children for supervisor/worker, verifier, fan-out or dependency-ordered work.
- A run detail page has a stop action.
- App status pills and browser nested rows show a parent/direct-child level.
- A parent can expand a task into child work and dependency-ordered execution.
- oz agent run executes on the current dev host; unmanaged execution supports macOS, Windows and Linux.
- Configured environments clone the authorized repositories.
- Inactive cloud environments shut down; continuation then uses Fork to local rather than reconnecting to a stopped VM.
- Environment images and setup commands define the toolchain and install steps.
- Worker idle-on-complete defaults forty-five minutes unless overridden; direct Agent API runs default ten minutes.
- Run detail panes expose transcripts and outputs.
- Run pages expose a timeline and cost.
- Managed workers support --max-concurrent-tasks; zero defaults to unlimited.
- Shared links expose the remote conversation, commands, logs and outputs to authorized teammates.
- Inherited Owner/Admin permissions govern administration; factory roles include Factory user and Editor.
- Factory role does not confer repository merge rights.
- Home shows questions, specs and PR reviews awaiting the current user.
- Authorized users send follow-up instructions through a shared active cloud session.
- Shared runs expose Computer Use artifacts when produced.
- A separate review agent checks requirements, tests and security expectations.
- The implement agent works on a branch.
- A person decides when/whether to merge; branch protection and repository permissions enforce that boundary.
- Factory handoff presents pull requests and evidence linked to the originating work item.
- Factory Inbox collects the current user’s question, spec-review and PR-review items.
- Hosted Warp services use the vendor’s product/services license agreement with limited access and…
- Customer-hosted workers execute jobs, but Warp hosts routing, tracking and control-plane metadata; the complete core…
- Warp retains control-plane operational logs, configuration, run metadata and billing records.
- Warp Factories is labeled Early Access in the current documentation navigation; standalone cloud-agent availability…
- Cloud runs support project guidance through Rules.
- Recurring maintenance uses factory automations or standalone schedules.
- Warp states SOC2 TypeII certification.
- Codebase Context provides indexed repository search subject to indexing settings and harness scope.
- Build is $20/month monthly or $18/month annually.
- Free is $0/month with core terminal features, limited cloud access and limited conversation storage; additional…
- Eligible dollar-billed accounts pay $3/agent-hour or $0.05/billable minute.
Sources
Open the Warp Factories / Oz page
Xumfreshness recheckresearch correction45 findings · 33 sources
Findings today
Sources
Open the Xum page
Zedresearch correctionfreshness recheck41 findings · 36 sources
Findings today
- Collaborators see shared files, cursors, navigation and edits, and guests can view read-only.
- The pinned README lists macOS, Linux and Windows downloads; minimum OS versions need the platform guides.
- Zed Agent runs alongside ACP-integrated External Agents.
- A separate existing-subscription setup route is documented; support must be checked per provider and agent path.
- The CLI opens arbitrary files or directories as editor workspaces; no Git remote is required for opening them.
- zed [OPTIONS] [PATHS] opens files/directories and supports --wait, --diff, --new, --add and --reuse.
- Zed native agents use locally spawned or remote MCP servers.
- Zed uses Rust and the GPU-accelerated GPUI framework for its editor/client.
- Users create native or installed external-agent threads from the panel/sidebar.
- Zed Agent loads personal AGENTS.md and the first matching compatible project instruction file.
- Native find_path and regex grep navigate project files.
- Zed task records are terminal commands, while agent history consists of conversation threads.
- Persistent channel Markdown notes can hold design/status ideas, but are not a typed requirements object.
- Multiple agent and terminal threads can run at once, against different projects.
- Native spawn_agent delegates a bounded task to a subagent with a separate context window.
- The native agent and agent UI start work from explicit session prompts.
- A stop button interrupts execution; a distinct durable pause mechanism is not established.
- Native Write, Ask and Minimal profiles provide different tool sets.
- Native agent terminal tools run shell commands in the project environment.
- A new agent worktree has its own checkout.
- Thread History can restore Zed threads; external-agent restoration depends on its integration.
- Project devcontainer.json defines the container image, dependencies and environment.
- Automatic compaction defaults at ninety percent of context; a configurable threshold or /compact is supported.
- The thread transcript shows streamed responses and tools in use.
- Active native threads show token usage near the model/profile selector.
- Business organizations have Owner, Admin, Billing Manager and Member.
- Native terminal commands are matched against regex allow/deny/confirm rules, including chained subcommands.
- Thread History retains archived conversations across projects until deleted.
- Review Changes opens a multi-buffer view of all agent-edited files and changed-line counts.
- Project Diff shows repository changes.
- The native terminal tool can run repository tests and return command output.
- The Git Panel reflects working-tree, staging and branch state, commits and undoes commits, manages branches and…
- Multi-buffer review groups the thread’s changed files.
- At commit 0dea8c63d9a5d747b3d0903adb110a9def1d1020, Zed's README states primarily GPL-3.0-or-later with Apache-2.0…
- The native editor/agent can use locally hosted llama.cpp, Ollama, LM Studio or customer-compatible endpoints on user…
- Zed does not retain prompt or code context by default; opt-in feedback/data sharing is separate.
- Plans and token allowances are quoted in US dollars.
- Personal $0; Pro $10 per month; Business $30 per seat per month.
- Zed publishes a stable editor release channel alongside other channels.
- Zed Free supports the editor, own API access and external agents; Zed-hosted models require a paid or trial route.
- Hosted-model usage is metered in tokens and converted to dollars.
Sources
Open the Zed page
Deltafreshness recheckresearch correction46 findings · 27 sources
Findings today
- Public-beta desktop, web/mobile browser and CLI surfaces differ.
- Delta supports its native agent, a Claude Code conversation-sharing plugin and a public-beta desktop Claude Agent…
- Provider subscriptions, keys, hosted credits and local models are supported separately.
- Git projects require configured remotes; projectless threads are separate.
- CLI provides thread/worktree/account operations.
- Skills, external MCP tools and CLI plugins have different scopes.
- Delta has a native desktop UI.
- Thread prompts and project context are primary intake.
- Plans can be files in retained thread history.
- Agent-created subthreads form a visible hierarchy.
- Skills, past-thread retrieval and compaction provide context.
- Agents retrieve prior threads and current project context.
- Native subagents execute in separate conversations.
- Profiles route model/effort and code ownership.
- Native agents delegate, message and receive child results.
- Threads support stop, questions and model continuation.
- Sidebar and organization Overview expose thread relationships.
- Interactive threads and delegated workers share flexible model settings.
- Public-beta desktop turns run locally, on user-managed Personal Runners including headless servers, or on Zed-hosted…
- DeltaDB checkouts separate code but do not sandbox agents.
- Deltas restore history while checkout and compaction recovery have limits.
- Repository preparation and private-runner setup are separate.
- Terminal cap and hosted spend controls have explicit enforcement.
- Thread status, context diagnostics and account telemetry are documented.
- Hosted/account usage follows the sender rather than thread owner.
- Concurrency controls apply only to legacy attached subagents.
- Authorized collaborators steer the same thread with explicit input ordering.
- Thread owner/editor permissions and membership are documented.
- Current agents have no tool approval system; secrets are redacted separately.
- Authored deltas retain edits and discussion between Git commits.
- Review threads preserve context and return verdicts with selected fixes.
- Teammates continue shared work while runtime-local state stays local.
- Deltas and review subthreads retain change evidence.
- Merge/review skills configure checks but are agent-executed policies.
- Git publication and explicit child integration are supported.
- Merge skills execute the chosen landing strategy.
- Edit-level revert and merge result references remain available.
- Review subthreads return verdicts and retained findings.
- Delta application access is governed by a restricted early-access agreement.
- Vendor account/synchronization dependencies remain distinct from local checkouts.
- Privacy docs distinguish synchronization, direct provider calls and account telemetry.
- Delta shares Zed Personal at USD 0, Pro at USD 10 monthly and Business at USD 30 per paid seat monthly.
- Fixed subscription and variable model usage are separate.
- Public beta and current releases are documented.
- Personal is an ongoing free plan with external model costs.
- Plan units and hosted spend limit are public.
Sources
Open the Delta page
Zencoderfreshness recheckresearch correction38 findings · 22 sources
Findings today
- Zencoder is an IDE extension for VS Code, JetBrains and Android Studio; standalone Zenflow is a separate profile.
- IDE Agent hosts native ZenCLI plus locally authenticated Claude Code and Codex; model choice is separate.
- Existing Claude and ChatGPT subscriptions can authenticate the IDE runtime.
- Install the IDE plugin, sign in and open a workspace; external CLIs have separate prerequisites.
- REST access covers organization analytics; official GitHub Action runs agent prompts in CI.
- IDE Agent is an MCP client with per-agent tools and standardized repository instructions.
- Prompt-driven IDE chat accepts Jira context; CI integration accepts PR events.
- Coding Agent creates an execution plan, but a durable native plan editor is not established.
- Personal and project memory are independently controllable; AGENTS.md supplies rules.
- Agents retrieve code, external docs and images, with a separately configured multi-repository index.
- Native ZenCLI can run parallel subagents; Claude Code has an explicit parallel subagent limitation.
- Humans choose named agents; the ZenCLI master can delegate specialized work.
- ZenCLI owns delegation through MCP subprocess calls that return results to the master.
- Official integration starts agent work on CI events; add-on entitlement must be confirmed.
- Inline diffs, follow-ups and tool approval prompts support intervention.
- Use the default Coding Agent, named custom agents or specialized children.
- IDE-hosted agent CLIs execute on the user's machine, and private deployments run agents and inference on customer…
- IDE tools edit the current workspace; vendor data isolation is separate from runtime sandboxing.
- External runtime installation and environment key handling are documented.
- Coding Agent tool-call count is uncapped per turn; runtime/tool errors remain inspectable.
- Structured logs expose tool inputs/outputs/duration and model errors with an Operation ID.
- Per-request credit usage is visible in IDE alongside remaining credits.
- Account administration has named roles and paid-plan SSO; repository retrieval has separate access controls.
- Tool permission prompts and per-agent tool selection bound execution; auto-approve is optional.
- Paid organization audit logs record identity, configuration and usage events and can be exported.
- IDE displays changed-file diffs with inline explanations and follow-up refinement.
- IDE shows diffs and execution traces; durable artifact gallery not established.
- Coding Agent runs tests/lint/types and self-corrects; configured review agents are optional.
- Native Git tools stage, commit, diff and manage branches; official CI integration can comment on PRs.
- Diffs and PR review comments provide bounded delivery evidence.
- The main service is proprietary software licensed for limited use.
- Customer infrastructure deployment is documented; account and provider dependencies remain.
- Recurring Free BYOK access and per-seat credit plans are public: Pro $45, Pro Plus $95 and Pro Max $195 per user per…
- Seat-only arithmetic is possible; no measured end-to-end engineering fixture cost.
- Current IDE plugins have published updates; rollout notes qualify newer integrations.
- Vendor claims SOC 2 Type II, ISO 27001 and ISO 42001; audit scope, issuer and validity are unverified.
- Free is recurring BYOK access, distinct from the seven-day bundled-credit trial.
- Seat fees, included credits, usage rules and cancellation are public; Enterprise remains custom-priced.
Sources
Open the Zencoder page
Zenflow Code by Zencoderfreshness recheckresearch correction45 findings · 43 sources
Findings today
- Desktop macOS/Windows/Linux and user-hosted browser access; phone client not established.
- Zenflow runs native ZenCLI, Claude Code, OpenAI Codex and Gemini CLI with per-step configuration.
- Claude native subscriptions or provider keys are supported; remote login is independent.
- Guided agent setup; code repositories and folder-based Work tasks have separate prerequisites.
- Zenflow is an MCP client with configurable tools and repository rules.
- Native tasks accept prompts, imported Linear context and configured GitHub events.
- Durable Markdown plans and workflow steps support edits and checkpoints.
- Organization/repository/task/subtask-chat structure and ordered steps are documented; dependency graph is not.
- Rules, skills and task artifacts provide retained context.
- Agents retrieve code, external docs and images, with a separately configured multi-repository index.
- Zenflow has native persistent task records and states, distinct from per-task chat tabs.
- PRD/spec/plan artifacts persist and can be reviewed before implementation.
- Parallel task worktrees and ZenCLI children support concurrency with harness limits.
- Humans dispatch tasks/presets and the native master delegates subprocess work.
- Product-owned master delegates isolated subagents and collects their results.
- Schedules and GitHub events start work unattended; remote host removes laptop dependence.
- Live chat/terminal activity, checkpoint pauses and notifications support intervention.
- Repository board/list offers source-documented fleet status; no scenario fixture executed.
- Quick Auto tasks can move into editable multi-step workflows and agent presets.
- Full Zenflow runs locally or on user-managed Ubuntu host and continues after laptop disconnect.
- Git worktrees separate code; MCP process controls and Codex sandbox settings are narrower scopes.
- Remote persistence, archival restoration and documented recovery differ from guaranteed crash resume.
- Repository scripts set up dependencies and copy local secret files; remote installs provide service/update controls.
- Agent errors and stuck runs have visible/manual retry paths.
- Task logs/tool streaming and verification states explain execution; analytics are account-level.
- Credits are provider/model-dependent; direct-key usage is paid to the provider.
- Parallelism is limited by host resources; docs recommend manual staggering and expose MCP-specific limits.
- Zenflow uses Zencoder account membership and paid organization SSO; same-task edit permissions not established.
- MCP approvals and runtime-specific execution modes can be configured.
- Git checkpoints and retained task history coexist with account audit logs.
- Diff, verification and configurable multi-model review provide review context.
- Task files retain plans/specs/reviews, diffs and verification context; archival differs from disk cleanup.
- Configured scripts and staged reviewers verify changes; hard authority enforcement is unverified.
- Zenflow creates task branches/PRs, commits and syncs PR status.
- Docs describe review/merge and configurable external tools; exact-revision authority gate unverified.
- Checkpoint rollback, PR links and retained review evidence support delivery traceability.
- Multiple finished tasks can be reviewed before sequential merging; no enforced dependency queue established.
- The main service is proprietary software licensed for limited use.
- Core Zenflow is installable on user infrastructure; data/history retention is documented.
- Recurring Free BYOK access and per-seat credit plans are public; model and own-host costs remain separate.
- Seat-only arithmetic is possible; no measured end-to-end engineering fixture cost.
- Zenflow ships desktop/remote clients with stable and beta channels; some settings remain experimental.
- Vendor claims SOC 2 Type II, ISO 27001 and ISO 42001; audit scope, issuer and validity are unverified.
- Free is recurring BYOK access, distinct from the seven-day bundled-credit trial.
- Seat fees, included credits, usage rules and cancellation are public; Enterprise remains custom-priced.
Sources
Open the Zenflow Code by Zencoder page
3 ADEs
Orchestrator.incproduct changeresearch correction48 findings · 61 sources
Findings today
- Orchestrator ships desktop, native mobile and CLI clients.
- Orchestrator launches and supervises external agent CLIs through compiled adapters, with structured Chat on a subset.
- Local use relies on the user’s own agent sign-ins and API keys; Orchestrator does not proxy model calls.
- Local setup is documented for Git repositories and Scratch work; Cloud and VM onboarding have separate flows.
- The ao CLI is the supported programmable surface; the local HTTP API is loopback-only.
- MCP and skills are inherited from the provider harness; Orchestrator has no plugin system.
- Desktop uses Electron and React over a Go daemon; mobile uses Expo and React Native.
- Work starts as a local prompt or session; GitHub and GitLab can feed workers one way, and they stay the issue authority.
- Chat keeps provider plans in session history; a durable task-plan record with acceptance criteria was not found.
- Orchestrator-to-worker supervision is documented; epics, blockers and dependency enforcement were not found.
- Project rules are typed and role-scoped; memory across sessions was not established.
- Multimodal input is provider-dependent; code search, indexing and architecture checks are left to the harness.
- Work is represented by worker sessions and external tracker intake, without an independent native task/issue record…
- Agents use the ao CLI on sessions and PRs; no issue object exists for them to manage.
- Parallel sessions run in isolated workspaces; local concurrency has no plan limit.
- PR ownership and feedback routing are enforced by the product; task queues and human assignment were not found.
- Product-owned orchestrator and worker sessions delegate, message and report across harnesses.
- Recurring Automations and built-in PR event rules run in the local daemon.
- Stop, resume, steer and attention are documented; a pause control was not found.
- A fleet board shows attention by session; a fixture walkthrough was not run.
- A quick worker and a project orchestrator run without mandatory workflows.
- Execution runs on the local computer, a linked self-hosted machine, or hosted Cloud sandboxes.
- Git worktrees and branches separate work by session; no OS sandbox claim was found for local runs.
- Sessions outlive client close and daemon replacement where hosts survive; recovery depends on the harness.
- Per-project setup scripts, symlinks and an optional preview launcher prepare workspaces.
- Setup and request timeouts are documented; run-level turn, token and spend limits were not found.
- Status derives from saved facts; session and project usage summaries exist for certified harnesses.
- Estimated session usage exists for Claude Code, Codex and Kimi; billed reconciliation was not established.
- Cloud concurrency is capped by plan; local resource-aware scheduling was not found.
- Cloud has organizations with admin billing controls; SSO and team management are not built.
- Permission modes come from each provider; safer and bypass modes are selectable per role.
- Session records persist locally for one user; no audit model was found.
- The inspector gathers PR state, reviews, files and preview; raw logs stay on the host.
- At v0.14.9 (checked 2026-11-06) the local system is single-user and colleague takeover was not offered; a session…
- Artifacts, previews, diffs and reviewer output are retained by session.
- Independent review is optional; merge gating stays with the repository host.
- Branches, worktrees, PR tracking, comment and CI routing, and conflict nudges are integrated.
- Merge is explicit and can pin the head SHA; release and deploy are outside the product.
- PR links and checks are tracked; deployment evidence and rollback were not found.
- The board supports a review queue; batch approval features were not found.
- Desktop, daemon, CLI and mobile are Apache-2.0; the hosted control plane is in a private repository.
- Local use needs no account; Cloud and account-linked remote hosts depend on the vendor.
- Local work stays on the machine apart from telemetry; AO Cloud data handling is outside the privacy policy.
- Public USD prices: Free, Starter $20/month, Pro $40/month and custom Enterprise.
- Only the fixed parts of a scenario can be priced from public sources.
- Stable releases ship frequently; support routes are public, with an SLA only on Enterprise.
- Local use is free with no account; Cloud needs a paid plan.
- Partially specified: plan prices and limits are public, while compute and Enterprise terms are not.
Sources
Open the Orchestrator.inc page
Capyresearch correctionfreshness recheck50 findings · 45 sources
Findings today
- Cloud VMs, desktop devices, Dock machines and movable threads are documented; own-cloud is Enterprise by agreement.
- Monthly plans grant shared credits, with no member fee; cloud compute and model usage have separate costs.
- Web and desktop clients are documented, a headless Dock CLI hosts threads, and docs state there is no mobile app.
- Capy runs its own agent plus a Claude Code mode, with a wide provider catalog; other native harnesses were not found.
- Subscriptions, keys and gateways work on every plan; cloud machine time, images and reviews always bill Capy credits.
- Cloud GitHub onboarding, repoless projects, desktop folders and Dock pairing are documented.
- A public bearer-key API covers threads, Captains, automations, reviews, usage and issues; capy dock is a device runner.
- MCP servers, marketplace plugins and portable repository instructions are documented.
- Prompts, Slack, Linear delegation and native Issues feed durable threads.
- There is no plan mode; plans live in prompts, Captain notes and Drive, with no acceptance-criteria field.
- Issues add sub-issues and blockers, and threads can grow into Captains; blocker enforcement was not established.
- Repository and Drive instructions, skills and saved files provide scoped shared context.
- Images, files and scoped Slack context are documented; architecture indexing and review enforcement are unverified.
- Native Issues (GA in 0.7.0) add backlog, assignment, labels and search separate from threads.
- Threads read, file, update and close shared issues, which are also in the public API.
- Repository specification files and Drive support an instruction-based spec workflow with human and agent edits and…
- Concurrent child agents and thread-level activity aggregation are documented.
- Issues hold assignees, and Captains and parents dispatch work; exclusive task claims were not established.
- Subagents and Captain crews delegate with explicit prompts, per-child models and returned results.
- Stored prompts support cron, GitHub/Slack events, webhooks and standing or fresh threads.
- Steer, interrupt and queued messages coexist with Stop run, Needs you and Failed status.
- Status, Needs you, Captain digests and issue blockers support an overview; no fleet fixture was run.
- A thread can stay simple or be promoted to a Captain that directs other threads.
- Cloud threads use Firecracker microVMs; device threads use worktrees and are explicitly not sandboxed.
- Thread history persists; an expired cloud machine is recreated from Setup and unpushed work is lost.
- Versioned setup, snapshots and startup entries prepare and rebuild managed environments.
- Credits and connection exhaustion have visible stop/recovery behavior; broad failure guarantees are unverified.
- Live progress and spend/token breakdowns are documented; aggregate metrics were not tested.
- Per-thread cost, usage splits and exports exist; child, epic and provider reconciliation were not established.
- Plan-specific cloud machine and concurrent-RAM limits are documented; compute-aware arbitration and verification…
- Work is shared in an organization by default, and anyone with access can write in a thread; live ordering was not…
- Org roles, membership changes and private thread/project sharing are documented; enforcement was not tested.
- Device access has approve, deny and always-allow controls; the merge rule is an instruction, and cloud commands have…
- Threads retain conversation/activity and Drive retains attributed file versions; immutable audit guarantees are…
- PR pages expose diffs, checks and findings, with review comments sent back to the agent.
- Ownership transfer exists and shared threads are open to teammates; runtime takeover was not tested.
- Threads retain PR/child results and Drive saves files beyond cloud-machine lifetime.
- CI failures trigger repair and dedicated reviews triage findings; spec gates and enforced branch policy are unverified.
- Branch/commit/push/PR creation, comments and CI follow-up are documented.
- The documented merge rule requires a specific explicit ask; technical authority enforcement is unverified.
- PR links and merge events connect results to durable threads; rollback mechanics are unverified.
- Pull request pages, review guides, findings and stacks support batch review; a six-task queue was not run.
- The Capy application and hosted service use vendor-authored terms.
- Threads stay in Capy cloud even on devices; own-cloud is Enterprise by agreement, and export is through the API.
- Capy documents storage, retention, deletion, subprocessors and telemetry, and provider terms apply on your own keys.
- Only the fixed and variable rate parts of a scenario can be priced from public sources.
- Public downloads and dated releases are available; support response commitments were not verified.
- Capy publicly states SOC 2 Type II and provides a Trust Center; the report scope and period were not inspected.
- Local threads on your own subscriptions or keys need no plan; cloud threads need a plan or balance.
- Public plan, model and hourly machine rates exist, with cancel/top-up controls and custom enterprise terms.
Sources
Open the Capy page
Podiumproduct changeresearch correction48 findings · 18 sources
Findings today
- Podium ships desktop, CLI and browser clients, including phone-browser control.
- Podium launches the native Claude Code, Codex, Grok, OpenCode, Cursor and Pi CLIs in persistent terminals on…
- Podium supports native coding-agent logins and managed provider credentials.
- Docs describe a first-run flow (install, podium, register a Git repository, confirm a detected logged-in harness)…
- The podium CLI covers issue create, show, update, claim, dependencies, artifacts, session send/status/read/stop and…
- Podium gives agents its own issue tools over CLI and MCP, and agent profiles import and export Claude Code agent files.
- Desktop releases use a Tauri 2 shell that serves the Podium web UI; mobile source uses Expo and React Native.
- Podium issue records are native and authoritative with stable references, CLI creation and editing, and agent-driven…
- Issue brief, acceptance criteria, state paragraph and todos persist on the durable issue record.
- Podium supports persistent parent and child issues, phases and typed dependency links, including reparenting an…
- v0.3.0 routes Podium issue instructions and relay environment through terminal and engine session launch.
- Not established.
- Podium exposes native issue creation with an optional start flag, separate dispatch, editing, comments, labels,…
- CLI and MCP address the same canonical issue records for reads, creation, edits, claims, state, dependencies and…
- The spec CLI and service (living specs under pspec with stable SP IDs) are in v0.3.0.
- Docs and release notes describe many sessions running as independent terminals, one worktree per issue, and several…
- Issues carry an assignee, claim sets assignee and in_progress, a coordinator session can be set per issue, sessions…
- Podium orchestrates delegation itself: podium agent spawn starts a full child session on an issue with a chosen…
- The server owns a scheduler for cron and one-time automations that spawn agent sessions, skipping overlaps and not…
- Chat and native CLI views share a session.
- Release 0.3.0 ships a flight deck showing a whole mission in one view: phases, every task and its state, who works…
- A quick task can be an interactive session or an issue; an issue can grow into a mission by gaining children while…
- The published Podium execution choices are local user machines and a user-owned VPS or paired machine.
- Podium separates issue files with Git branches and worktrees, but its released daemon launches native host processes…
- Closing a browser tab does not stop the agent process on a running Podium host.
- Only machine setup is documented: the installer installs missing runtime tools and pairs a host, and the state…
- Podium exposes retryable errors, optional auto-continue with backoff, bounded waits and provider quota.
- Podium offers local logs and crash export, structured session status, issue stats, a usage and analytics sheet with…
- Since 0.2.0 Podium shows what each task costs, on the task header and the usage sheet, with per-session rows and…
- Podium reports host memory, load and disk, auto-hibernates idle sessions under pressure, and provides named advisory…
- The issue UI displays owner and visibility read-only and deliberately omits sharing controls.
- Podium defines member/admin instance roles and admin-only membership management.
- Agent-session management requests go through an operator approval broker with approve and deny; the privacy docs say…
- Issue actions, approval steps, comments and mail are recorded server-side.
- Review is a documented loop: issue stage review, diff and checks, artifacts, offers with merge or send-back buttons,…
- The durable issue, session transcript, artifacts and mail persist for any later agent, and a live session can be…
- Artifact commands store immutable server-side copies of issue-linked files, including images, video, HTML and…
- In the experimental Shipping path a configured validation profile runs before landing (default argv bun run test…
- Issues own branches and worktrees, and issue actions rebase, open a pull request with gh (pr create --fill) and…
- The operator accepts work through offers and runs the merge action under a branch merge-lock; in the experimental…
- Shipping orders record approved base and head SHAs, tested integration SHA, landed ref and validation result in a…
- The shipping service records revision-specific approval, configured validation and delivery receipts.
- The public repository is licensed Apache 2.0, and the website presents Podium as an open-source agent development…
- Local desktop and self-hosted installs run on user-controlled machines with a documented state directory.
- Docs state repositories and native harness credentials stay on machines you control and server state lives in a…
- No Podium price is published: podium.do/pricing returns 404 and the docs list billing as not implemented.
- Podium is pre-1.0.
- Podium is open-source Apache-2.0 software, and the download page calls it free and open source.
Sources
Open the Podium page
Archived event links
Something wrong or missing?