November 2026 status archive, page 21 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
10 ADEs
T3 Coderesearch correction2 findings · 5 sources
Findings today
- v0.1.7 documents installed Codex, Claude Code, Cursor, Grok Build, Kiro (beta, Early Access), OpenCode, Antigravity,…
- Agents run on the user's own machine or a machine they keep running (SSH, T3 Connect, LAN/tailnet); clients on other…
Sources
Open the T3 Code page
Temboresearch correction1 finding · 3 sources
Findings today
Sources
Open the Tembo page
Traycerresearch correction3 findings · 7 sources
Findings today
Sources
Open the Traycer page
Unpeelresearch correction1 finding · 3 sources
Findings today
Sources
Open the Unpeel page
Vibe Kanbanresearch correction3 findings · 6 sources
Wakuresearch correction3 findings · 4 sources
Findings today
Sources
Open the Waku page
Warpresearch correction2 findings · 4 sources
Findings today
Sources
Open the Warp page
Xumresearch correction3 findings · 5 sources
Findings today
Sources
Open the Xum page
Zedresearch correction1 finding · 2 sources
Findings today
Sources
Open the Zed page
Zencoderresearch correction2 findings · 3 sources
10 ADEs
Agent Deckinitial researchresearch correctionfreshness recheck33 findings · 4 sources
Findings today
- CLI/TUI ships for macOS and Linux; Windows access uses WSL.
- Many terminal coding agents are supported with different integration levels.
- Agent authentication is reused for local/container sessions, with a macOS Claude exception.
- Install binary and add a directory with an installed tool; remote setup can install deck on SSH host.
- CLI exposes session creation, send, stop, fork, parent relationships, MCP, skills, costs and remotes.
- Product manages MCP and skills per supported coding tool.
- Sessions carry semantic goal/state/ticket annotations but external ticket references do not establish native issues.
- Session parent linkage represents delegation, with a documented remote-parent boundary.
- Conductor identity, shared policy and learnings persist in files.
- Fleet board cards and work states are session annotations.
- Independent tmux-backed sessions run concurrently and show process/work state separately.
- Conductors dispatch and monitor sessions; native issue claims were not established.
- Persistent conductor sessions orchestrate workers and receive status nudges.
- Heartbeat/watchers and optional chat-service bridges trigger session work.
- Conductor auto-responds or escalates; users can send and stop sessions.
- TUI and web Fleet/Command Center expose grouped session state and attention.
- Users can work directly in sessions or enable conductors and configure tool/model choices.
- Sessions run locally, in Docker or on user-owned SSH/cloud hosts.
- Git worktrees and Docker containers separate execution scope.
- Session resume/fork support is tool-specific; remote failures are visible and retryable.
- Worktree hooks initialize task environments; Docker setup may require separate authentication.
- Cost budgets and run token/turn/time defaults are configurable, with explicit untested enforcement limits.
- Status lights and semantic annotations are separate; roadmap lists detection gaps.
- Session costs and tokens are collected from provider transcripts/output, with limited provider verification.
- Web mode has token and read-only controls; shared token is not organization RBAC.
- Conductor task-log and semantic decisions persist, without an audit integrity guarantee.
- Transcripts, forks and archives retain session work.
- Product manages worktrees and branches.
- Agent Deck repository is MIT licensed.
- Core TUI, web server and conductor run on user-controlled machines.
- Usage telemetry is opt-in and has CLI preview/disable controls.
- Public releases and community support are available.
- MIT source/direct binary installs support local evaluation with own tool accounts.
Sources
Open the Agent Deck page
Agent of Empiresinitial researchresearch correction25 findings · 13 sources
Findings today
- aoe serve starts the released browser dashboard.
- Docs list Claude Code, OpenCode, Codex CLI, Gemini CLI, Cursor CLI, Pi and other agent CLIs as supported and…
- Agent credentials and native stores remain harness-specific.
- Install AoE and tmux on Linux/macOS, then add an installed agent or start the dashboard.
- CLI includes add, list/ps, send, wait, fork and session lifecycle operations.
- Configured MCP server definitions are forwarded to structured-view agents when a session starts; terminal sessions…
- Users create local agent sessions through CLI, TUI or dashboard.
- Profiles, repository configuration/hooks and custom agent commands configure session behavior.
- Agents run in parallel across separate branches/worktrees.
- Session lifecycle and global killall controls stop workers; killall is explicitly destructive and unprompted.
- Structured view supports explicit model and reasoning effort choices subject to cached provider options.
- AoE runs agents on the operator local or SSH host and optionally the configured container runtime.
- Optional worktrees and Docker/Podman/Apple Container sandboxes separate sessions.
- The TUI can reattach persistent tmux sessions after reconnect.
- Sandbox seeding uses private agent stores and a shared Claude credential file with documented refresh behavior.
- TUI/browser status detection and CLI ps provide a runtime session overview.
- Optional per-container CPU and memory limits are configurable; no global compute-aware queue is established.
- An MCP client has the same access as the keyboard user; AoE adds no per-tool permissions.
- Diff line comments can be edited and sent as a follow-up prompt with the captured snippet.
- The browser/TUI diff viewer displays changes against selectable comparison bases.
- AoE manages session worktrees and branches, without a built-in PR creation/management workflow in this scoped core.
- AoE uses MIT with a separately documented Apache-2.0-derived hyperlink file.
- The full daemon, session manager and optional web dashboard run on user-controlled Linux/macOS hosts.
- Anonymous telemetry is off by default and requires opt-in.
- README links public issues, documentation and community channels.
Sources
Open the Agent of Empires page
Agent Teamsinitial researchresearch correctionfreshness recheck35 findings · 5 sources
Findings today
- Desktop supports macOS, Windows and Linux.
- Claude Code, Codex and OpenCode are managed runtimes.
- Use existing provider subscriptions or API keys, or start with a free unauthenticated model.
- Download desktop app, choose project, define team roles/provisioning prompt and launch.
- Built-in MCP server and agent plugins support tool integration; universal secure plugin system remains roadmap work.
- Desktop app uses Electron 40, React 19, TypeScript, Tailwind and Zustand.
- Humans create tasks on the board or send attachments to the lead, which creates described tasks.
- Task descriptions, comments and attachments retain assignment context.
- Organizations can nest teams and show dependencies/delegation.
- Instructions and task context survive compaction through app recovery mechanisms.
- App owns shared tasks with descriptions, comments, attachments and durable board status/history.
- Agents create/manage shared tasks and leave comments visible to humans.
- Multiple teams across projects and their agents can work in parallel.
- Agents plan, delegate and create shared tasks through the app's orchestration layer, and the team lead turns a human…
- App-owned lead/teammate orchestration exposes cross-team direct/group messages, task comments and review.
- App-owned scheduler dispatches due persisted schedules through a runtime process executor.
- Direct messages course-correct agents, diagnostics/restart address stuck teammates, and board badges flag human input.
- Organization map shows nested teams, agent status, tasks, dependencies and cross-team messages; no high-load fixture…
- Teams may begin in solo mode, expand later, and use provisioning prompts to set roles and branch rules.
- Teams execute as local processes on the desktop host.
- Selected teammates can get worktrees at launch.
- Task context persists; app has compaction recovery and guarded nudges after known rate-limit cooldowns.
- Monthly token/estimated-cost budgets offer threshold alerts; supported scheduled Claude runs can receive a…
- Per-task logs show tool actions and messages; analytics and live process/resource sections expose activity.
- Token analytics include input/output/cache/reasoning and estimated cost across tasks, agents and runs.
- Users can require manual approval for supported tool actions, with readable requests and notifications.
- Task timeline records state changes, participants and workflow actions.
- Task diff review supports accept, reject and comments on individual hunks.
- Tasks retain attachments and matched runtime logs/changes, with document and code preview/editing.
- Main application public repository uses AGPL-3.0.
- Core desktop app and local orchestration run on user hardware; app does not have a cloud backend for storing project…
- App says it does not upload/sync project code to Agent Teams servers.
- Application is free.
- Latest listed v2.18.6 was published November 5; current release requires macOS 13+, with older 2.17.1 for macOS 12.
- Free app can begin with a free model requiring no signup, key or card; other providers retain their costs.
Sources
Open the Agent Teams page
ai-devkitinitial researchfreshness recheck29 findings · 11 sources
Aletheinitial researchfreshness recheck37 findings · 7 sources
Findings today
- Desktop supports Windows/macOS/Linux; optional LAN browser remote control has separate input opt-ins.
- Multiple agent CLIs run in independent PTYs, with cross-agent context handoff.
- Agent credentials remain in underlying CLIs; provider quota reads use native signed-in accounts.
- Desktop installers and agent CLI launcher detection support setup; first-task timing was not measured.
- Product manages coding-agent MCP and skills plus a permission-declared plugin system.
- Desktop is Tauri/Rust with React and xterm.js, not a fully native widget UI.
- Projects organize local work and sessions; optional todos and orchestration are separate capabilities.
- Official orchestration skill writes bounded briefs and result artifacts.
- Playbook canvas supports worker/check/condition graphs; task-DAG roadmap is a separate effort.
- Local session/history and MCP/skill state persist; handoff uses a bounded context packet.
- Graphify exposes a project code graph through MCP.
- Bundled Todo List persists per-project tasks separately from agent PTYs.
- Independent agent PTYs and opt-in orchestrator workers run in parallel.
- Opt-in MCP coordinator delegates worker briefs; arbitrary DAG dispatch is not inferred.
- Opt-in MCP-delegate orchestrator supports Claude planner to Codex workers, with an optional standalone official skill.
- Worker steering/approvals, PTY input and group suspension support intervention.
- Project panes and opt-in worker board expose active sessions, without a tested 12-state fleet fixture.
- Direct PTYs coexist with optional playbook delegation; not all task-DAG roadmap work is shipped.
- Agents execute on the local desktop host.
- Git worktrees and provider-scoped approval controls are implemented.
- Workspace and supported agent sessions survive layout changes/restart; context transfer has limits.
- Resource, activity, worker cost/token and quota displays are documented.
- Orchestration reports use CLI-reported worker spend; no provider bill reconciliation was performed.
- Remote Control defaults read-only; agent and shell input require opt-in, with LAN transport limits.
- Git/PR panels and worker diffs support review while PR AI review is read-only.
- Cross-agent handoff preserves a selected context packet; colleague/runtime takeover is not established.
- Worker artifacts, project panes and local backups retain outputs.
- Playbooks may include checks/conditions, and PR merge checks guard current head.
- Git Control handles status/stage/commit/branches/diffs and worktree PR lookup.
- Squash merge is an explicit human action guarded against stale head/draft/conflicts.
- Clean worker worktree apply and stale-head merge guard are documented.
- Application source is AGPL-3.0-or-later; hosted future services have separate scope.
- Local core requires no Alethe account and has profile backup/settings/cloud export controls.
- Privacy guide distinguishes local diagnostics, default network polls and optional cloud services.
- The desktop is free.
- Early public desktop release has installers and public issue support.
- Free desktop/core supports evaluation with own agents; cloud features are separate.
Sources
Open the Alethe page
Archoninitial researchresearch correction42 findings · 43 sources
Findings today
- Archon has a product CLI and self-hosted browser console.
- Maintained provider plugins run Claude Code, Codex and Pi using their CLIs/SDKs.
- Archon runs existing Claude Code, Codex and Pi accounts.
- Users install a provider, install Archon and run a named workflow in a git repository.
- Archon exposes a REST API under /api with OpenAPI 3 generation.
- Versioned plugins supply workflow packs, agent providers, forges and chat adapters through a published contract and…
- The SDLC pack takes GitHub issues through intake, build and merge queues via the forge plugin.
- YAML workflows declare ordered or dependent agent, script, loop, wait and approval nodes, with output contracts and…
- A workflow node can launch separate child runs with their own identity, artifacts, costs and pauses.
- Archon reuses provider project guidance and stores workflow commands and scripts beside YAML.
- The discoveries workflow reads out-of-task findings and files them as new GitHub issues or attaches them to existing…
- Workflow fan-out creates concurrent governed child runs and max_parallel limits active children.
- The build queue claims ready issues; the merge queue processes ready PRs and returns conflicts for rework.
- The product assistant can invoke workflows and inspect runs; workflow nodes delegate child runs with output returned…
- Native schedules, GitHub events and Standard Webhooks request governed runs with host identity, overlap policy and…
- Console actions include approve, reject, resume, cancel and abandon.
- The console lists runs across projects and exposes per-run event logs, artifacts and graph context; alerts announce…
- Users invoke a ready workflow in natural language or edit the YAML graph to combine agent prompts, scripts, waits,…
- Archon can run locally or be deployed with Docker or on a cloud VPS for always-on operation, using SQLite by default…
- Repository runs receive their own Git worktree by default, permitting separate runs against the same repository.
- Normal container pauses stop compute; resume can restart or recreate the container from its persisted upper volume.
- Container runs require Docker and a current runner image containing tools.
- Optional run budgets enforce work-unit and provider-reported USD spend ceilings before new attempts.
- Run details expose event logs and artifacts; live events show governance state.
- Child run costs roll up into parents without duplicating prior resumed increments; per-run token and provider-cost…
- Trigger bindings declare host, shared resource and overlap policy and share admission records.
- New identities are members.
- Workflow approval gates pause for explicit approve or reject decisions, can rework on rejection and record decisions…
- Each run retains an event log, transcript and cost in the user database.
- Operators open run details with event logs and artifacts and approve, reject, resume, cancel or abandon runs from…
- The console retains workflow events and artifacts, but the scoped product UI has no dedicated proposed-code/diff…
- The SDLC build queue plans, implements, reviews through specialist lenses and fixes findings; its merge gate checks…
- The forge-backed SDLC pack opens PRs, waits for CI and sends conflicting PRs back through build work before merge.
- The merge queue checks a ready review and CI against the head commit and base health before merging.
- SDLC output links the issue and pull request with a ready-review result and exact-head merge checks.
- Build and merge queues coordinate ready issues and PRs, review verdicts, CI and conflict rework.
- Current Archon application source is MIT licensed at the pinned revision.
- Archon is a full self-hosted application on the user machine or server, using SQLite by default or PostgreSQL.
- Archon sends anonymous categorical workflow/platform/provider/outcome and numeric usage events, excluding code and…
- The current core Archon application is free MIT software to install and self-host, with no paid ADE tier in the…
- The repository released v0.14.0 on November 7.
- The core app is available as free MIT software to install and self-host; paid model and own-compute costs remain…
Sources
Open the Archon page
Open-Inspectinitial researchresearch correction37 findings · 20 sources
Findings today
- The primary product UI is a web workspace with sessions, automations, review and settings.
- OpenCode, Claude Agent SDK and Codex are separate selectable harnesses; each session keeps its initial harness for life.
- Claude account works on Claude Agent, ChatGPT account on supported OpenCode/Codex routes, and SuperGrok on supported…
- The setup guide separates running the web app against an existing backend from a full self-hosted deployment, and…
- Control-plane session endpoints include budget updates and operator/service exports, with role/token authorization.
- Managed shared/personal MCP connections are available with harness-specific loading restrictions.
- The client package is Next.js web; no native desktop shell was established.
- Web prompts, Slack, GitHub PRs, Linear issues and webhooks can start coding sessions.
- Sessions retain child/grandchild relationships with a bounded depth and separate sandbox/branch per child.
- Harness-native repository instruction files and pinned managed skills provide session context.
- Parent continues while independent child sandboxes run simultaneously.
- Automation admission rechecks executor/target permission; denied scheduled authorization pauses the automation.
- Child can override model/reasoning but inherits its parents harness and authentication.
- Cron automation starts ordinary sessions without a human prompting each run.
- Authorized collaborators can stop the current session turn.
- Operators self-host the control plane and configure their own remote sandbox-provider accounts for agent execution.
- Each child gets its own branch and sandbox rather than the parents working branch.
- Provider-specific expiry can snapshot/restore or stop/pause/archive and later resume retained state.
- Prebuilt images and saved-state models differ by provider; Modal supports per-turn snapshots while several backends…
- A reported USD session limit stops active work and blocks queued/new prompts until the owner raises/removes it.
- Sessions share token/tool/step/warning events across harnesses; child history can be retrieved programmatically.
- Budget sidebar displays reported session cost and configured limit.
- Child spawning fails when the configured concurrent limit is reached; it is not described as silently queued beyond…
- Participants and connected-presence dots update for viewers in the same session.
- Owner, Administrator, Member and Viewer have documented workspace permissions.
- Credential brokering caches data on disk and snapshots can retain it; GitLab uses a deployment PAT.
- The audit UI records operation/authorization outcomes with actor/resource snapshots; Allowed is not evidence the…
- Changes panel has path filters, unified/split views and Markdown preview with session-start/head context.
- An authorized colleague can open history, queued prompts and current sandbox state and continue the same branch.
- Changes includes committed/uncommitted tracked and nonignored untracked files since session start, with named…
- GitHub PRs and checks are review evidence; a failed-test or requirement-conflict shipping gate was not exercised.
- Each child branches from the parents base branch in its own sandbox.
- Child UI and session review expose linked pull request state and navigation.
- The web/control-plane application source uses MIT.
- Full self-hosted deployment is documented, with the control plane on Cloudflare Workers by default or in a container.
- Snapshots can retain on-disk cached credentials; removing a grant does not instantly revoke issued tokens.
- Public repository, changelog and setup guides provide support context without a response commitment.
Sources
Open the Open-Inspect page
bbinitial researchresearch correction35 findings · 17 sources
Findings today
- Desktop supports macOS arm64; Linux x64 and Windows x64 installers are alpha.
- Installed Claude Code, Codex, Pi, Cursor via ACP, OpenCode, Grok Build and other compatible ACP agents are documented.
- Codex accepts ChatGPT login, while Claude uses the signed-in CLI and reports its plan.
- Install/download bb, authenticate at least one agent provider and open the served app.
- bb CLI exposes thread and project operations; plugin commands extend it.
- Built-in provider, task, automation, memory, capacity and MCP plugins extend bb.
- The repository documents an Electron desktop shell around the web app.
- Tasks plugin creates product-owned task records independent of running threads.
- Task descriptions, subtasks, comments and attachments supply durable worker briefs.
- The Tasks plugin supports subtasks and nested folders; arbitrary blocker enforcement remains unverified.
- Global/project memory has provenance, kinds, tags, versions and a summary catalog injected each turn.
- Product-owned tasks support create/edit, board/list views, filters and task detail.
- bb tasks CLI reads and writes the same stable task keys shown to humans.
- Managed worktrees allow concurrent threads without changing the main checkout.
- Task delegation selects provider/model/effort/permissions and attaches a worker thread.
- Manager threads coordinate child threads; provider-native subagents can be disabled to route delegation through bb.
- Automations support repeating cron/timezone and one-shot schedules.
- Live threads can receive steering through browser, CLI and HTTP/SDK surfaces.
- Default launcher starts server and local host daemon on the current machine.
- Managed worktrees separate checkout directories/branches.
- The launcher restarts crashed server/daemon child processes separately.
- Per-worktree setup scripts install dependencies before dispatch; failure or 15-minute timeout blocks thread start.
- The changelog describes failing provider turns accepted but not started after five minutes.
- Service logs rotate and SQLite thread events retain timeline progress.
- New idle-thread turns queue at host/global capacity and recheck after another thread settles.
- Approved remote MCP app grants can be revoked.
- Threads retain an append-only stream of messages, tool calls and file changes in server state.
- The Git Diff tab displays uncommitted, branch and per-commit diffs with Viewed marks and filters.
- Managed worktree environments create separate branches for parallel work.
- PR merge actions are provided by the GitHub PR status plugin; exact-revision authority enforcement is unverified.
- Thread Info retains the linked pull request even when the above-composer PR panel is hidden.
- bb application source is MIT licensed.
- The central server, SQLite state and execution daemons can run on user-controlled machines.
- Optional storage-retention plugin sets archive/delete policies and defaults to disabled.
- README calls the project active development and Linux/Windows desktop alpha.
Sources
Open the bb page
Boltinitial researchresearch correction37 findings · 39 sources
Findings today
- Bolt works in Chromium desktop browsers and Safari.
- Bolt supplies Standard and Max agents, plus Forge for eligible accounts.
- Bolt subscriptions provide token allocations for builder usage; Free use refreshes daily and monthly and paid…
- Users start with prompts, Figma, Stitch, GitHub or a Lovable import.
- A project owner can connect built-in or custom MCP servers to Bolt and authorize external tools and data.
- A natural-language prompt creates a project; GitHub and design imports bring an existing starting point.
- Plan Mode lets users discuss an approach before code changes, then switch to building after refining scope.
- Project settings store project knowledge for the agent, separate from a single chat prompt.
- Code view permits browsing files and paths for references in prompts.
- A Bolt project has one shared chat and processes one prompt at a time; prompts sent during generation are queued.
- Bolt queues later prompts from collaborators until the current project prompt completes.
- Chat tools let users queue follow-up prompts while Bolt is busy and manage the queued requests.
- Users can build and refine with natural-language chat, change agent choice and optionally edit source directly.
- The development environment runs on WebContainers, which run Node.js in the browser.
- Bolt can create and switch GitHub branches and keeps branch-specific memory.
- Built-in version history lets users restore earlier project versions.
- Chromium Code view exposes a terminal to run project commands; Safari does not expose the terminal.
- Free use has daily and monthly limits.
- The GitHub panel shows Syncing or Synced status, linked repository and active branch.
- Builder usage is measured in tokens and visible in account usage.
- Shared-project prompts run serially and excess prompts queue.
- Collaborators prompt and edit the same project in one shared chat.
- Team Admins manage membership, roles, billing, project controls and integrations; Members build within those controls.
- Only the project owner manages the GitHub connection.
- Project version history and restore preserve prior code states.
- Users can leave threaded feedback on preview elements.
- Collaborators share a single chat and project, while GitHub sync waits for the original project owner to return.
- Bolt exposes a live app preview and source through Code view.
- Users can run a project security audit on paid plans or a database security check on all plans, review the findings…
- Bolt creates and switches branches and automatically syncs project changes to GitHub.
- Bolt does not currently merge branches in-app; users merge through GitHub.
- Users can restore prior project versions and export project backups.
- Project code can be downloaded as a backup and synced to GitHub.
- Bolt offers Free, USD 25/month Pro, USD 30/member/month Teams and custom Enterprise at monthly billing.
- Release notes document database tables becoming private by default starting October 30 and expanded phone browser…
- The ongoing Free plan supports build, publish, viewer/editor/co-owner project sharing and recurring daily/monthly use.
- Plans disclose token allocation, monthly or annual billing and a downgrade to Free when paid cancellation takes effect.
Sources
Open the Bolt page
claude-code-actioninitial research25 findings · 10 sources
Archived event links
Something wrong or missing?