November 2026 status archive, page 24 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
20 ADEs
OpenAI Codexfreshness recheckresearch correction43 findings · 23 sources
Findings today
- Codex is available inside the ChatGPT desktop app on macOS and Windows; Linux is a preview on the distributions…
- Codex supplies its own coding harness.
- Supported local Codex clients can sign in with ChatGPT.
- Install the CLI, open a project directory, run codex and authenticate; elapsed setup time was not tested.
- codex exec runs non-interactive tasks in scripts and CI.
- The CLI supports packaged skills and plugins.
- Client implementation: The desktop and mobile apps act as remote clients of the app-server daemon; their own UI…
- Intake and external tracker relationship: Tasks are threads started from the CLI, SDK or codex cloud exec; there is…
- Durable task plans: The update_plan tool publishes and updates a step plan in the thread.
- Hierarchy, dependencies and evolving scope: Subagent threads persist under parents and come back when a parent is…
- Shared context and memory: Codex reads AGENTS.md before beginning work.
- codex --search enables live web search with visible search activity.
- The public CLI supplies a per-turn update_plan checklist inside a conversation event stream.
- Each cloud task has its own workspace; the page gives no concurrency quota.
- Ownership and dispatch: spawn_agent takes an optional agent role; there is no human assignment or task claim object.
- Local custom agents can set model and reasoning effort; unspecified children inherit their parent.
- Desktop Codex supports recurring tasks with an RRULE custom cadence.
- The interactive CLI accepts steering during the active turn.
- Fleet and epic management UI: Subagent threads are tied to parents and restored with them; the default TUI workspace…
- A scheduled task can choose default or explicit model and reasoning effort.
- The CLI inspects, edits and runs tools in the local project.
- Codex supports local OS sandboxing, user-managed devcontainers and Git worktrees.
- Phone worktree control still requires the execution computer awake; this is distinct from cloud tasks that run while…
- Cloud setup identifies and installs repository runtimes, dependencies and tools.
- Provider SSE idle timeout defaults to 300,000 ms and is configurable.
- Opt-in OTel exports structured API, tool, approval and stream events.
- Per-task API and compute cost: turn.completed (TypeScript) and TurnResult (Python) report token usage.
- Compute-aware scheduling and verification: agent_max_threads defaults to 6 and is configurable.
- Business includes SAML SSO; Enterprise adds SCIM and RBAC.
- Local approval policies control escalation beyond the sandbox; /permissions exposes read-only and other configurations.
- Opt-in OTel tool-decision events retain approved or denied decisions and decision source.
- Review experience and guidance: Patch details expand in the transcript during approval.
- Cloud review shows changed files and check results.
- A dedicated local review can inspect uncommitted changes, a commit or a base branch and return prioritized findings.
- Cloud results can be committed or opened as pull requests after review.
- Completion evidence and rollback: thread/revert rewinds a thread in the app-server; code rollback was not established.
- The repository LICENSE at fc01c073b9ea09c06347a234a1ca231a9ef65bf5 is Apache-2.0; hosted components and separate…
- The Codex CLI and App Server core can run on user-controlled infrastructure under the public source distribution.
- The Business plan states no training on business data by default; consumer routes are not covered by this statement.
- Codex offers Free and recurring paid ChatGPT plans, with separate API-key billing.
- The Linux desktop client is in preview, with named x64/ARM64 distribution packages.
- A $0 monthly plan includes limited desktop Codex usage, subject to rollout.
- Prices distinguish individual subscriptions, Business seats and separate API usage.
Sources
Open the OpenAI Codex page
Conductorfreshness recheckresearch correction23 findings · 41 sources
Findings today
- Conductor documents a macOS app and an iPhone app requiring iOS 26.0+.
- Beta HTTP API (/v0, OpenAPI), hosted Streamable HTTP MCP server and routine webhooks; Conductor CLI exists in cloud…
- API/MCP (beta, cloud workspaces) can create sessions, send prompts, cancel the current turn and read transcripts; an…
- Cloud scope.
- Managed Cloud (Vercel sandbox, us-east-1) keeps agents running after the Mac app closes until sandbox sleep or…
- Cloud preserves files and chat history across sleep but not running processes; interrupted turns must be resent.
- Cloud sandboxes enforce sleep and lifetime limits; Codex chats retry on OpenAI rate limits (0.84.0, no surface named).
- API session status distinguishes idle, working and errored; failed Cloud startup exposes setup logs.
- Experimental cloud cost estimates (Codex, 0.77.0) exist; per-task cost reporting is otherwise not documented;…
- Each Cloud workspace is documented with 8 vCPUs and 16 GB RAM; concurrency limits, resource-aware scheduling and…
- The revised announcement documents transferring Cloud workspaces to local and exporting an account archive.
- The pricing URL redirects to the homepage without a price table.
- One-, two- and five-person scenarios cannot be priced from the checked public pages because current subscription…
- Conductor has withdrawn its wind-down plan.
- Pricing is partially specified: model billing stays with the provider and Cloud FAQ states no additional compute fee…
- Local workspaces have todos that block merging until checked off.
- Workspace todos exist; an independent issue backlog is unverified.
- The local app keeps chats and files on the Mac (~/Library/Application Support/com.conductor.app and ~/conductor),…
- Local workspaces and chats stay on the Mac, model requests go to the configured provider, and analytics go to PostHog.
- Local workspaces use a git worktree and branch each without an OS sandbox; Cloud uses isolated Linux microVM sandboxes.
- Cloud routines run saved prompts on schedules (including weekdays), GitHub actions with filters, or webhooks;…
- Shared Cloud workspaces support live chats, presence and typing indicators; private workspaces exist; Pro…
- Cloud organizations have admins and members.
Sources
Open the Conductor page
Cursorfreshness recheckresearch correction16 findings · 54 sources
Findings today
- Cursor is reachable from a desktop app (Mac, Windows, Linux), a CLI, a web client at cursor.com/agents, a native…
- Cursor runs its own coding-agent loop with selectable models.
- A Cursor account uses the new X Subscription or a retained legacy Cursor plan.
- Cursor exposes a CLI with headless mode, a public-beta Cloud Agents REST API, a TypeScript SDK, and signed status…
- Projects let a coordinator agent plan larger bodies of work and delegate to cloud agents; task dependencies,…
- Spend limits bound cloud usage; time limits and timeouts are not stated.
- Token usage is available per agent and per run through the API and SDK; billed dollar cost per agent is available…
- New subscriptions cost $8 Plus, $30 Premium, $100 Super or $200 Ultra monthly; Teams seats $30/$100/$200.
- Fixed new-plan examples only: one Premium user $30/month; two Premium Teams seats $60; five $150.
- Cursor announced its completed acquisition by SpaceX on August 14, 2026 and described continued product development.
- Free has limited core use.
- New-plan seat rates and annual prices are public; usage pools are weekly and third-party models prepaid.
- Cloud agents accept follow-up runs and CLI sessions can be resumed.
- Plan Mode saves editable Markdown plans for later reference and user-directed implementation.
- Agents open pull requests (ready for review unless a draft is requested).
- PR, deployment and check status appear in mobile, and Rollouts monitors deploys for regressions and notifies the…
Sources
Open the Cursor page
Devinfreshness recheckresearch correction50 findings · 14 sources
Findings today
- Devin Desktop, formerly Windsurf, has macOS, Windows and Linux downloads; Linux packages specify glibc >=2.28 and…
- Desktop supports Claude Code, Codex CLI, OpenCode and Gemini CLI through ACP in addition to Devin Local.
- Pro, Max and Teams explicitly support using a ChatGPT plan.
- Install the CLI for the host OS, restart the terminal, enter a project directory and run devin.
- The devin CLI runs local sessions and creates, steers and resumes cloud sessions, including single-turn scripted use.
- Devin cloud security profiles can allowlist installed organization MCP servers.
- Vendor statements only: Devin Desktop is a full IDE built on the Windsurf IDE and stays compatible with Windsurf and…
- Devin accepts work based on Linear/Jira tickets; tracker synchronization and authority are not established here.
- CLI Plan mode (/plan) agrees an approach before edits, but no durable plan object is documented.
- A coordinating session can split work into subagents that open their own PRs (devin.ai/desktop product page), and…
- Knowledge stores reusable instructions and tips; new guidance should use Skills because Knowledge is deprecated.
- Devin Desktop retrieves relevant code with the Fast Context subagent; repositories are indexed for Ask Devin and…
- Sessions are the work items: they start from any client or the API, take tags from an organization allow-list, can…
- Through the v3 API, session messages and attachments stay retrievable, and RBAC permissions and service users govern…
- Devin runs several cloud sessions in parallel.
- Adaptive routing in Devin CLI picks a model per task, and an organization default platform places cloud sessions on…
- The CLI main agent delegates independent workers using profiles, in the foreground or background, and receives and…
- Devin management tools expose schedules; scheduler reliability and overlap handling were not established.
- Foreground child tool calls can request human approval; background unapproved tool calls are denied.
- The Devin Desktop Agent Command Center shows local and cloud sessions together, with coordinator rows listing…
- A session starts from a prompt in Devin CLI, Desktop or the API.
- Devin CLI and Desktop local sessions execute on the user computer; cloud sessions use Devin VMs.
- Cloud sessions run on VMs.
- A cloud session keeps running when the local terminal closes.
- Devin cloud environments are set up from organization and repository blueprints built into snapshots, with build…
- Spending is capped by plan allowances, prepaid credits and admin limits: Teams has 3 usage tiers, self-serve admins…
- The issue timeline and analysis identify problems and recommendations in completed sessions.
- Insights reports session ACU usage; this is a compute usage unit, not a complete reconciled monetary bill.
- Concurrent cloud sessions are capped at up to 10 on Pro and Max and unlimited on Teams and Enterprise, plus 2…
- Teams supports multiplayer sessions.
- Service users have roles; creating sessions as another user requires ImpersonateOrgSessions.
- In Devin CLI and Devin Local, Normal mode asks before writes and shell commands; allow and deny rules apply per tool…
- Sessions created as a user appear in that user's list and count toward their usage; this is documented attribution,…
- The Review inbox lists authored, assigned and awaiting-review PRs.
- A human can interact with the embedded IDE and browser; second-account takeover and owner-disconnect behavior were…
- Cloud sessions expose shell output and development tools, and session messages and attachments stay listable through…
- Devin Review reviews PRs from the UI or API.
- Devin returns draft PRs for review and follows up on CI automatically by default (admins can turn this off).
- Devin Review can submit GitHub PR approvals with the required connection.
- The Devin Desktop board lists each session's PRs with Merged or Closed state (vendor illustration), and /revert in…
- Devin Review lists PRs awaiting review.
- Cognition provides Devin under proprietary service rights: restricted access/use is licensed to customers and all…
- Outposts self-hosts tool execution on user infrastructure, while the agent loop, inference, planning and queue…
- The web application processes user-provided data; installed integrations have separately configured access.
- Prices are USD.
- Published fixed self-serve costs: Pro $20/month and Max $200/month per individual, and Teams a flat $80/month…
- Knowledge is deprecated, with gradual automatic migration to Skills in Plugins and removal in a future undated update.
- Cognition states SOC 2 Type II certification since September 2024.
- Free includes a light agent quota, limited models and unlimited inline edits/Tab completion in desktop; free cloud…
- Individual usage is a daily and weekly quota, with model-dependent message consumption.
Sources
Open the Devin page
Emdashresearch correctionfreshness recheck45 findings · 20 sources
Findings today
- Classic automations let users choose the agent, provider options, prompt and workspace for scheduled runs.
- Automation history and PR checks expose timing, status and errors.
- Classic lists provider-specific auto-approve, which skips file-operation permission prompts, and confirms before…
- Classic supports staging, commits, pushing and pull request creation inside its diff interface.
- Classic links current-head PR checks to GitHub and can discard unstaged changes with confirmation.
- Classic documents allowlisted default-on PostHog telemetry and opt-out; agent provider policy remains separate.
- Emdash Classic supplies desktop clients and SSH remote workspaces.
- The Library manages reusable prompts, skills and per-machine MCP configuration.
- Classic stores reusable prompts, skills and MCP configuration with explicit machine scope.
- Scheduled prompts run on project machines and retain reviewable history.
- Optional tmux preserves terminal processes/history across view closure or SSH loss, with host reboot excluded.
- Classic offers diff inspection and PR check/comment context in the task workspace.
- These docs cover shipped Classic; Emdash 2.0 is described as early-access/waitlist separately.
- Classic has a fixed list of 35 coding-agent CLI adapters, including Claude Code, Codex, OpenCode, Cursor, Pi, Grok…
- Emdash runs the provider CLIs the user installs and signs in to.
- Install an agent CLI locally or on the selected remote machine before starting work.
- The scoped Classic application has no standalone product-owned user CLI.
- Classic desktop uses Electron.
- Tasks accept branch, external issue or PR context.
- Classic uses the linked issue context and initial prompt as the task brief, linked to branch, worktree and pull…
- Classic offers editor find/replace, language intelligence and app search, MCP-based external knowledge and file or…
- Classic persists workspaces and conversations linked to external tracker issues.
- Classic documents parallel coding agents in separate worktrees.
- Classic launches user-selected agent sessions and renders provider-native subagents.
- Provider hooks expose attention needs and resumable sessions.
- Classic shows per-conversation attention and status signals, automation run history and a per-machine conversation…
- Classic executes locally or on the user SSH machine.
- Classic creates task worktrees or uses an existing checkout.
- Remote previews have explicit port forwarding and manual collision guidance.
- v1.2.10 removed a 30-second failure on long workspace operations.
- Classic shows Claude Code and Codex subscription usage windows; it does not compute task or session cost.
- Automation runs queue behind a concurrency cap; machines show resource usage without limiting work.
- Classic is a local desktop/SSH application with no multi-user shared prompting service in its scoped source.
- Classic has no application organization roles or enterprise SSO.
- Classic keeps saved conversations per task and automation run history on the user's machines; no multi-user activity…
- No colleague takeover was established in Classic; within a task, new conversations can use a different agent without…
- Task diffs and browser previews are documented.
- Classic displays GitHub Actions checks.
- Classic advertises merging reviewed changes in the app.
- Classic repository is Apache-2.0.
- Classic operates on local or user-operated machines.
- Classic is free Apache-2.0 desktop software using user-installed agent accounts, subscriptions and provider keys;…
- Classic itself costs nothing; agent subscriptions or API usage and machine costs are external and not modeled by Emdash.
- Classic is advertised as free; agent and machine costs remain separate.
- Classic is free with no resale of compute or model usage; Emdash 2.0 pricing is not published.
Sources
Open the Emdash page
Factoryfreshness recheckresearch correction49 findings · 19 sources
Findings today
- Factory App now offers macOS, Windows and Linux desktop installers.
- Factory runs only its own Droid harness, with hosted models from Anthropic, OpenAI, Google, xAI and Droid Core open…
- The recurring Free plan supports native ChatGPT and GitHub Copilot sign-in, OpenRouter, provider API keys and custom…
- Non-Git folders can start sessions without a worktree.
- Droid CLI supports terminal use and headless exec; exact operation parity remains uncollected.
- Droid is an MCP client with a registry and OAuth, uses Factory-managed Connectors, plugins, hooks, skills and…
- Automation starters include Ticket to PR and Error Triage; external tracker authority was not tested.
- /missions creates a plan with features, milestones and success criteria before approval.
- Mission features are grouped into milestones; arbitrary hierarchy and dispatch enforcement were not tested.
- The shared folder contains plans, findings and deliverables readable and writable by all agents across machines.
- Droid reads and searches local files without a required index; Connectors and MCP add external knowledge, AutoWiki…
- The documented native CVE Tasks tab has persistent task IDs and states, plans, PRs and a timeline, but is explicitly…
- Delegated agents read Linear or Jira issue fields, post progress and PR links back and move backlog issues to…
- The orchestrator divides areas among agents working in parallel.
- The workstream orchestrator assigns an area and brief to each agent.
- A lead orchestrator delegates to Droid sessions; each agent reports progress, blockers and results and can be opened…
- Factory App Automations supports cron-style recurring runs.
- The UI stops an individual agent turn.
- Agents are separate Droid sessions reporting to one workstream orchestrator.
- The guide recommends starting a new Mission for structured work rather than converting a long-running ordinary session.
- Workstream machines may be the local computer, configured remote computers or fresh cloud machines.
- A new worktree creates its own branch from a selected base by default.
- Persistent worktrees never clean up automatically; ephemeral worktrees are eligible unless a session is pinned.
- A computer may start from a successful Environment snapshot; later Environment rebuilds do not mutate the existing…
- Workstream agents stop at plan or organization usage limits until reset.
- App connection states include connecting, connected and error; induced-failure consistency was not tested.
- Workstream Usage lists each session credit consumption and its share of total.
- Workstream defaults describe additional machines for orchestrator routing.
- Slack delegation supports follow-up instructions in one active session thread or dedicated code channel.
- Owner, Manager and User have distinct organization permissions.
- Autonomy levels, permission rules and an opt-in OS sandbox gate commands, MCP tools, network and paths, with…
- Enterprise owners can inspect organization administrative events.
- The PRs tab lists each workstream PR with its checks and review activity.
- Sessions can be shared with the organization or forked, shared delegations continue through follow-ups, and cloud…
- Workstream shared files retain plans, notes, findings and reports.
- Missions describe user-facing QA validation and self-correction, requiring an automated scriptable application setup.
- Workstreams track PRs opened or worked on by the orchestrator and agents.
- A PR tab has a Merge button and status.
- Workstream PRs can be opened in-product, on the Git host, or copied as links.
- Workstream PRs are grouped by lifecycle state.
- Factory application software is governed by a limited custom internal-use license in Individual Terms.
- Enterprise Custom Deployments can run all of Factory inside the customer network using the dedicated airgap build.
- Airgap execution and files remain inside the customer network, subject to its infrastructure egress rules.
- Factory has a recurring Free plan and paid subscriptions from $20/month.
- Fixed monthly plan prices are established (factory.com/pricing read 2026-11-21): one person pays $0 on Free with…
- Workstreams is beta on Pro, Plus, Max and Teams, explicitly not yet Business or Enterprise, checked 7 November 2026.
- Factory lists ISO 27001 and ISO 42001; exact certified entities and product scope require the reports.
- Factory now offers a recurring $0/month Free plan using the user inference account or keys; paid plans remain…
- Business and Enterprise require a quote; exact rolling usage limits and computer costs were not established by the…
Sources
Open the Factory page
GitHub Copilotresearch correctionfreshness recheck50 findings · 14 sources
Findings today
- COPILOT_OFFLINE=true fully disables CLI telemetry and GitHub network requests; configured model-provider traffic…
- The Copilot desktop app supports macOS, Linux and Windows, including optional WSL2 execution on Windows.
- GitHub supports public-preview Anthropic Claude using Claude Agent SDK and OpenAI Codex using Codex SDK alongside…
- Partner Claude and Codex agents can use the existing Copilot subscription; this does not establish use of separate…
- Cloud work requires repositories hosted on GitHub; other Git hosting is explicitly excluded for this workflow.
- copilot -p runs a single prompt and exits; tool approval flags scope execution.
- Cloud work supports MCP; personal MCP and connectors in cloud sandboxes differ from repository MCP on Actions.
- Official docs state only that the app is built on GitHub Copilot CLI; the desktop UI framework is not documented.
- The GitHub.com chat/agent flow accepts repository-context prompts.
- CLI plan mode asks clarifying questions and builds an implementation plan before code changes.
- Parent issues hold sub-issues; projects group by parent issue.
- Custom instructions, skills and custom agents apply with environment-specific configuration.
- GitHub chat documents semantic code search limited to default branches.
- Copilot drafts GitHub repository issues for human submission.
- Copilot can propose issue creation with human draft review.
- The Copilot app runs multiple sessions simultaneously.
- The orchestrator assigns context and tools to subagent tasks.
- The main agent is the orchestrator and assigns subagent tasks.
- Automations run on schedules.
- Steer this session sends further direction from a project.
- A project coordinates related sessions across repositories.
- Chats run without a branch or workspace, and a focused session can start directly in one repository.
- Default project tasks run against the local machine; --cloud selects GitHub-hosted compute instead.
- Desktop sessions use Git worktrees and local OS sandbox restrictions.
- The user does not need to stay connected while a cloud sandbox works.
- Cloud sandbox state is snapshotted while a session is stopped.
- Actions-based Copilot sessions stop after a maximum 59 minutes; the limit cannot be extended.
- Session logs record work and tools used; GitHub says logs do not replace review and testing.
- Each subagent independently consumes model usage and can increase GitHub AI Credit consumption.
- Agent tasks can be queued.
- Repository collaborators can follow shared work.
- Enterprise owners set the Copilot in the cloud and third-party agent policies; organization owners block…
- Automation GitHub-tool writes can be scoped to all repository resources or the triggering issue.
- Shared automation definitions and runs are visible to repository readers; writers can edit them.
- The app lets users review proposed session changes and PRs in-product.
- Shared automations belong to the repository and keep working after the creator leaves; a colleague continuing the…
- Project Library retains reference material and generated artifacts.
- Cloud development sessions can run tests and linters; required delivery gates were not tested.
- CLI documentation gives commit and revert examples, separate from tested delivery behavior.
- The app can leave a PR review; exact revision binding and enforced authority were not established.
- Commit messages link to session logs.
- My Work and PR filters in the app.
- Copilot application/service use is governed by custom GitHub or Microsoft terms according to purchaser and plan.
- Copilot CLI can run on user infrastructure without a GitHub account in offline BYOK mode, using a local/in-network…
- At the 7 November check: Pro $10/month, Pro+ $39/month, Max $100/month, Business $19/granted seat/month and…
- One person: Pro $10, Pro+ $39 or Max $100 per month, plus credits beyond the allowance at $0.01 and cloud sandbox…
- Copilot is not available for GitHub Enterprise Server; model and feature availability depend on policies and spend…
- A SOC 2 Type 2 report is listed for enterprises and the 2024 post confirms Type II Copilot coverage; newer Copilot…
- Free has limited features and an AI-credit allowance; the plans page says all plans include CLI and the Copilot app.
- Business/Enterprise include pooled credits with separately billed excess usage; Copilot access has no included usage…
Sources
Open the GitHub Copilot page
Intent by Augmentfreshness recheckresearch correction49 findings · 9 sources
Findings today
- Desktop, self-hosted browser and iOS access are documented; Windows/Linux desktop are Alpha.
- Intent runs multiple named coding harnesses with provider and model selection per specialist.
- Intent uses native provider account logins and supports separate Codex/Claude profiles.
- Onboarding supports local Git repos, cloned repos, new Git repos and remote service setup.
- Product CLI manages the daemon and access; agents call the workspace API.
- Intent connects MCP servers and imports repository instruction/skill context.
- The 2026-11-07 first-party pass checked Intent access and providers; Intent context and tasks; Intent Git workflow;…
- Users create workspaces from prompts, local projects, GitHub PRs and Linear issues.
- Spec and Task Notes retain goals, scope and acceptance criteria.
- Task blocks express dependency and conflict metadata.
- Specs, notes, MCP and discovered instructions are shared workspace context.
- Notes link code and external tools; browser evidence supports visual inspection.
- Persistent Task Notes provide native work records beyond agent chats.
- Agents create and update the native task notes visible to users.
- The workspace Spec is a living shared requirements document.
- Multiple agents and workspaces can run concurrently.
- Humans and Coordinator agents assign task notes to specialists.
- Coordinator delegates to inspectable specialists and receives results.
- Daemon hooks and PR monitors start follow-up work from events.
- Stop, steer, queued follow-ups and structured questions are available.
- Home and Fleet HUD expose agents across workspaces.
- Single Developer tasks and Coordinator teams share configurable workflows.
- Run locally or place the background service and agents on a user-controlled remote machine.
- Workspaces use dedicated Git worktrees and branches; Work directly can disable isolation.
- Daemon-backed state and transfers preserve documented conversation/code material with process-history limits.
- Saved setup scripts and remote preview forwarding help prepare workspaces.
- Provider quota failures can retry on another profile; idle reaping and agent caps bound activity.
- Streaming output, token views and workspace status are documented.
- Token usage is visible by agent/model; cost appears only when reported by provider.
- The daemon bounds agent concurrency and memory by host RAM.
- An owner and invited collaborators can send messages to the same workspace agents under separate human principals.
- Workspace owner, Participant and Manager roles enforce different permissions.
- Remote device access uses explicit pairing and token rotation.
- Persistent notes and comments retain decisions; transfers exclude event history.
- Review diffs, spec evidence and inline comments inside Intent.
- The 2026-11-07 first-party pass checked Intent access and providers; Intent context and tasks; Intent Git workflow;…
- Workspaces retain documents, diffs and browser verification captures.
- Verifier specialist checks batches against spec; browser checks can record visual evidence.
- Intent owns Git diff, commit, PR and merge UI.
- Users can merge a PR or workspace branch inside Intent.
- Workspace timelines link commits and PR state and support local undo.
- Home lists workspaces and reviewable PRs; merge queue state comes from GitHub.
- Intent application repository is Apache-2.0 licensed.
- User hosts Intent background/web services; workspace transfer preserves selected data.
- Remote docs disclose plaintext web machine-token storage; iOS uses Keychain.
- Intent describes its desktop app as free and Apache-2.0 open source, with no paid plan or price published; model…
- Desktop is free; Windows/Linux are Alpha and current updates are documented.
- Intent describes a free desktop application; provider usage remains separately authenticated.
- The 2026-11-07 first-party pass checked Intent access and providers; Intent context and tasks; Intent Git workflow;…
Sources
Open the Intent by Augment page
Jeanresearch correctionfreshness recheck46 findings · 14 sources
Findings today
- Jean has desktop builds for macOS, Windows and Linux, plus full host-served browser access.
- Linked projects, saved context summaries and reusable prompts provide session context.
- Jean exposes backend-specific steering and archived/unread session attention.
- Jean exposes editable workflow presets and session-specific model, effort and execution modes.
- Jean records run logs and exposes issue-sweep error status; operational accuracy is untested.
- Jean exposes diffs, saved context and review findings alongside retained session history.
- Jean reads backend MCP config and exposes global, project and session enablement.
- Jean accepts images, files, tracker context and linked repositories.
- Local and self-operated Linux server execution share browser/native access; remote agents continue when the…
- Jean stores chat/session state and archive metadata on the host.
- Jean supports inline diff comments and revisitable AI review findings.
- Jean supports worktrees, commits/push, PR actions and conflict resolution.
- Jean has confirmation before reverting the last local commit.
- Jean states there are no paid tiers or feature gates; agent and server costs are supplied by the user.
- Jean is downloadable with macOS tested and Windows/Linux builds needing further testing.
- Jean explicitly offers a free application without paid tiers, feature gates or usage caps.
- Jean runs installed coding CLIs with model and effort controls.
- Jean uses the user existing CLI subscriptions and authentication.
- The Linux server has documented binary/systemd onboarding.
- Jean exposes authenticated HTTP/WebSocket and product-owned MCP project, session and shipping operations.
- Desktop uses Tauri 2 with React; headless server uses Tokio/Axum.
- Intake starts from external repository and tracker context.
- Jean documents Plan, Build and Yolo sessions with saved context.
- Jean tracks project worktrees, labels and chat sessions and imports external GitHub/Linear context.
- Agents in a Jean session can read GitHub and Linear issues, start worktrees and sessions, and get delegated run…
- Jean advertises parallel agents in worktrees and multiple sessions per worktree.
- A session can hand work to another session through Jean MCP (create_session with a chosen backend, then…
- v1.0.14 describes linked child sessions and automatic delegated-result return.
- GitHub issue sweeps remain a beta workflow; new Agents access is restricted.
- Canvas groups worktrees by state; the fleet fixture is untested.
- Jean separates task files with Git worktrees; agents share the operating-system user.
- Jean persists chats, archive metadata and native backend session IDs; crash fixtures were not run.
- jean.json defines setup and teardown scripts, run commands and named ports for each worktree; saved secrets are…
- Issue-sweep automation documents bounded failed-start retries and GitHub rate-limit deferral.
- The desktop app's session debug panel (debug mode is an Experimental setting) shows token usage and a cost breakdown…
- Mr.
- Web Access lets anyone holding an instance's single token open the same projects and sessions from another browser;…
- The application has one instance-token access boundary, with no named human organization roles.
- Remote access defaults to token authentication; current release changes browser sign-in storage.
- Jean shows PR status and checks on worktree rows and offers an optional separate Review session (also run_review…
- The documented PR flow includes merge.
- The desktop canvas has a PR filter tab and a review-ready state, and sessions keep recaps and stored Review findings.
- Jean source distribution is Apache-2.0.
- Jean has user-operated desktop and headless-server routes.
- Jean keeps working state on its host and documents archive deletion and saved-secret handling separately from…
- Jean is free and open source (Apache-2.0 covering the desktop app, jean-core and jean-server) with no paid tier, and…
Sources
Open the Jean page
JetBrains Airfreshness recheckresearch correction17 findings · 77 sources
Findings today
- Air is reachable through the Air app on macOS, Linux and Windows, Air Teams in the browser, and Air in JetBrains…
- Air in IDEs runs local coding agents through ACP and terminal surfaces, explicitly including Claude Code, Codex and…
- Air in IDEs runs agent sessions on the user's machine by default, with Local and Temporary Worktree modes, and Air…
- In the documented current release, Air Teams usage tracking covers JetBrains AI only, and the Air app credit counter…
- Console Business is $20 per seat per month (monthly or annual billing); 1 AI credit equals 1 USD of provider-side…
- Fixed Air Governance Business seats are $20, $40 and $100 per month for one, two and five users.
- Air is in early access: the Air app is under an EAP user agreement, Air in IDEs is EAP, Air Teams is available to…
- Air app EAP terms allow free app use; AI usage is separate.
- Units are AI credits (1 credit per 1 USD of provider-side LLM cost) and Business plan AI seats at $20 per seat per…
- Plan mode lets the agent write a plan as a Markdown file in .air/plans before implementation and the user approves…
- Air app Plan mode stores Markdown plans and asks for implementation approval.
- Air Teams automations run in the cloud on a schedule, at an interval, or from GitHub, Jira or webhook events without…
- Run environment is selectable: Local Workspace (no isolation), Git Worktree, Docker (local) and Cloud; worktree and…
- Air Teams documents only per-task capacity and stopping: a cloud task runs on a selected predefined VM size, and a…
- In Air Teams cloud tasks, permission modes belong to each agent: the selector on the New Task page shows the…
- Central Console keeps an immutable audit log of organization administration changes (not AI activity) with CSV…
- Cloud tasks commit to a task branch and push after every agent turn; a person then opens the pull request from that…
Sources
Open the JetBrains Air page
Julesresearch correctionfreshness recheck44 findings · 21 sources
Findings today
- Jules loads AGENTS.md at the repository root.
- Development environment reliability: Repository setup scripts install project dependencies.
- Client access: Jules has a browser client; mobile action parity was not established.
- Agent and model choice: Only the Jules agent runs tasks; the complete plan comparison lists Gemini models only and…
- Subscriptions, API keys and vendor credits: Jules Pro/Ultra benefits are included in corresponding Google AI plans…
- Repoless REST API sessions create an ephemeral cloud environment from a prompt without a source repository.
- remote list, remote new and remote pull manage cloud sessions; --parallel creates several runs.
- External tools and extensions: MCP client support covers only Linear, Stitch, Neon, Tinybird, Context7 and Supabase.
- Client implementation: No desktop app is documented; Jules Tools is a terminal CLI/TUI.
- Applying the jules label to a GitHub issue starts work and returns a PR link; GitHub remains the issue system.
- A task presents step-by-step implementation plans with assumptions and setup details.
- Task creation accepts PNG/JPEG images totaling under 5 MB; this guide excludes follow-up image attachments.
- Native issue management and idea backlog: Users create tasks, not issues.
- Agent-native issue operations: Session IDs are shared across the API, CLI and web URLs.
- Humans request edits to the proposed plan through chat; direct structured requirements editing is not established.
- The guide lists Free/Pro/Ultra daily task caps of 15/100/300 and concurrent caps of 3/15/60, checked 7 November…
- Ownership and dispatch: Adding the jules label to a GitHub issue assigns it to Jules; there is no other assignment…
- Inspectable delegation and communication: A code critic and a Planning Critic review Jules's work; users cannot…
- The UI can pause work and later unpause it; this was documented rather than tested.
- Fleet and epic management UI: Failed and waiting tasks are labelled, and a red badge marks errors.
- Workflow flexibility and orchestration visibility: A prompt produces a plan to approve, then the task runs.
- Laptop-independent execution: Jules Tools is a remote-session client; the coding worker executes in Google cloud VMs.
- Each task runs in its own short-lived VM; no adversarial isolation test was run.
- Immutable API activities can be used to reconstruct the session’s history; this does not prove process recovery.
- Jules retries eligible failed steps such as network or transient install failures.
- The live activity feed reports steps, outputs, errors and feedback requests.
- Per-task API and compute cost: The allowance is tasks per day and concurrent tasks by plan; no per-task cost is shown.
- Free, Pro and Ultra allow 3, 15 or 60 concurrent tasks.
- Live human collaboration: Paid plans are for individual accounts only; Workspace upgrades are not offered.
- Roles and access boundaries: Paid plans cover individual Google accounts only.
- The guide says an unattended plan eventually auto-approves on a timer; plan review is not an indefinite…
- Session activities record the steps taken by user and agent.
- The expanded diff editor shows all files Jules changed.
- The feed includes mini diffs and a full changed-file diff editor.
- Verification and spec gates: Setup scripts can run tests before snapshotting.
- Commit authorship is configurable as Jules, coauthored or user-only.
- Merge and deployment authority: Users merge PRs in GitHub; the experimental fleet package can merge PRs sequentially.
- The task summary identifies branch and commit details; a direct commit permalink was not established.
- The hosted Jules application is governed by the vendor-authored Google Terms of Service linked from Jules.
- The diff editor has download/copy controls for generated changes.
- Jules explicitly does not train models on private repository content.
- Price and included usage: Plans are per individual account; family plan members each get their own limits, and…
- Jules documents a recurring plan available without cost; service turndown restricts the remaining availability window.
- Plan task allowances are 15/100/300 daily and 3/15/60 concurrent.
Sources
Open the Jules page
Kirofreshness recheckresearch correction48 findings · 20 sources
Findings today
- The IDE supports macOS, Windows and listed modern Linux distributions; Crew has separate desktop support.
- Crew 0.12 exposes a fixed registry of Kiro/KAS, Claude Code, Codex, OpenCode, Pi, Goose, DeepSeek, Strands and…
- Crew external backends reuse their own native sign-ins and credential stores.
- IDE installation requires sign-in and opening a project; measured setup time was not tested.
- kiro-cli runs headless with a paid-plan API key; the Enterprise Management API is in preview; ACP connects clients.
- Kiro documents MCP, project agent definitions and steering across IDE, CLI, Web and Mobile.
- The Kiro license page states that Chromium is the IDE’s underlying engine.
- Crew Projects accepts a prompt or uploaded Markdown specification for a task run.
- A spec produces requirements.md or bugfix.md, design.md and tasks.md.
- Steps can declare dependencies; independent tasks run in batches.
- Workspace .kiro/steering and AGENTS.md guide sessions; global local files do not automatically appear in cloud…
- Steering files can carry product, technology and project-structure context; runtime architectural compliance was not…
- Crew Projects creates task runs from a prompt or uploaded spec.
- Task Runner injects the spec, working memory and prior Git state into each step.
- Feature specs persist requirements.md, design.md and tasks.md.
- Spec task execution can run independent tasks in parallel on IDE, CLI and Web; the matrix excludes mobile.
- GitHub issues are assigned to the agent per user with write permission; the same issue assigned by two users creates…
- Kiro supports custom-agent subagents and opt-in Workflows in IDE, CLI and Web, with results returning to the parent.
- Crew Schedule creates recurring jobs in separate sessions; continued execution depends on its Gateway host.
- Approvals requested with no client attached wait for the next attaching client.
- Default chat for quick tasks, custom agents, prompt-generated or recipe workflows (opt-in) and mid-session autonomy…
- Crew runs on the user's machine, container or controlled remote host; the desktop app can connect through an SSH tunnel.
- Each task uses its own kirocrew/task/ branch.
- Task Runner reconciles interrupted steps after a Gateway restart.
- Kiro Web sandboxes auto-configure from manifests and take environment variables and secrets.
- kirocrew run --timeout sets a run timeout.
- Enterprise prompt logs and per-user activity exports; Web marks auto-approved and blocked tool calls.
- The account dashboard updates credit usage at least every five minutes; pooled admin usage has separate dashboards.
- Crew allows three concurrent task runs and parallel batches of three independent steps.
- Crew 0.12 ships opt-in Shared Crew collaboration: owners can admit distinct people over Tailscale, and the source…
- Organization sign-in supports IAM Identity Center or external IdP such as Okta and Microsoft Entra.
- Spec force_approval gates can protect deployment/publish steps.
- Cloud session history persists in the session store, IDE chats export, and Crew logs security decisions.
- IDE supervised mode shows agent-generated file changes for review.
- Sandbox file state persists with the session and PR diffs show under Reviews.
- Task steps run tests before committing unless --no-test is selected.
- The Web spec flow implements tasks and opens a PR or merge request, with later feedback updates.
- Kiro Web explicitly says it never merges changes automatically; the user reviews before the default branch is changed.
- Crew retains per-step commits and can revert a failed independent-review step before retry.
- Kiro IDE and CLI use the AWS Content and AWS IP License terms.
- The Crew Gateway and dashboard run locally, in Docker or on a user-controlled remote host; Kiro/model-service…
- Improvement content can include generated code, questions, other inputs and responses.
- Monthly individual prices are Pro $20, Pro+ $40, Pro Max $100 and Power $200, checked 7 November 2026.
- Plan and pooled-seat prices give fixed monthly costs; per-task credits vary by model and task.
- Mobile is TestFlight early access on iPhone and Google Play on Android, separate from IDE/CLI/Web availability.
- Kiro is in AWS's ISO/IEC 27001:2022 scope (EY CertifyPoint); reports via AWS Artifact; certificate not inspected.
- Kiro Free provides fifty credits monthly for limited listed models; cloud/Web access is not implied.
- Credit pricing is public but model choice and work complexity prevent deriving a fixed per-task cost.
Sources
Open the Kiro page
Lanes Desktopfreshness recheckresearch correction43 findings · 19 sources
Findings today
- Lanes Desktop is available for macOS Ventura+; other desktop platforms remain roadmap items.
- Claude Code and Codex have first-class integration; provider gateway support is scoped.
- Existing agent authentication is reused; gateway profiles add own-key/local-model routes.
- Install Mac app, add project and installed harness, then start issue session.
- Local Desktop MCP exposes board, session and history operations as research preview.
- Product plugins teach agents the built-in MCP and tracker workflows.
- Desktop is built with Tauri 2, React, Rust and SQLite.
- Native issues can import GitHub/Linear tickets and post results upstream.
- Issues retain instructions, and plan-mode sessions propose work before editing.
- Dependency edges govern automatic pickup but allow manual board movement.
- Versioned project JSON shares reusable commands and launch settings.
- Agents reach GitHub and Linear issues through the Desktop MCP, and files or dictation can be fed into sessions; no…
- Native board issues persist independently of sessions.
- Concurrent sessions can run on one or several issues.
- An external MCP-connected agent can launch and inspect Lanes sessions.
- Unattended loops are configured in the connected harness and require the desktop app.
- Terminal steering, session stop/resume and attention state are documented.
- Board shows work, dependencies, runtime attention and history.
- Quick commands and MCP workflows support configurable session chains.
- Desktop sessions execute locally; remote board sync is not proof of remote agent compute.
- Each issue can get a branch/worktree; sibling sessions share it.
- Session history can resume; worktree cleanup warns about dirty work.
- Per-worktree quick commands and setup scripts prepare development.
- Run limits are left to the orchestrating loop: Lanes documents loop recipes with timeouts, iteration caps and…
- Live states and retained history expose operational progress.
- Session metrics include token usage and cost without a stated billing reconciliation.
- Queue auto-pickup and bounded external loop guidance are documented.
- Permission prompts belong to each harness and MCP client; Lanes adds plan-mode starts and keeps Gateway credentials…
- Built-in inline diff and commit history support review.
- Issue worktree diffs and transcript/tool outputs are inspectable.
- Test Worktree runs user tests; separate checker loops are documented workflow patterns.
- Git UI commits/publishes branches; session gh creates PRs.
- Complete & Merge can commit/merge a worktree and finish its issue.
- Commit history supports undoing the latest unpushed local commit.
- A Review column holds issues awaiting human review, with bulk actions.
- Desktop README specifies proprietary licensing; separate Lanes Link is not the desktop license.
- Local desktop issues/settings use user-machine SQLite; hosted parity is not established.
- Local data and a crash-reporting opt-out are documented; a usage-telemetry opt-out is not established.
- Free solo plan and $19/month Pro workspace plan include Desktop.
- Free costs $0 for one user and Pro $19/month for up to 10 members; agent work runs on owned hardware and model usage…
- Mac desktop v0.50.0 released; MCP and gateway are research previews.
- Free-forever one-user plan includes Desktop and unlimited local sessions.
- Public workspace price is disclosed; external provider charges remain separate.
Sources
Open the Lanes Desktop page
Linzumifreshness recheckresearch correction42 findings · 4 sources
Findings today
Sources
Open the Linzumi page
Maestroresearch correctionfreshness recheck45 findings · 22 sources
Findings today
- Maestro exposes Claude Code project memory for reading, editing and deletion, and passes provider-configured skills…
- Released desktop Cue sends prompts on file changes, timers, scheduled times, agent completions and GitHub events.
- Auto Run supports presets, model options and queued steering notes between tasks.
- Agent Resilience pending retries do not survive quitting the app; Cue engine restarts mark in-flight runs failed,…
- The Usage Dashboard shows per-agent, group, Auto Run, Cue, token and time views with JSON/CSV export that includes…
- Multiple people can prompt the same Maestro through browser clients.
- History persists summaries with session links, supports deletion and has a configured buffer.
- Auto Run has human-gate and halt markers; History Validated is explicitly only a bookmark.
- Maestro runs locally and can export Cue bundles for user-owned headless servers.
- Anonymous check-in and optional folder sync have explicit data and conflict limits.
- Maestro has public issue support and released/RC scopes that differ.
- Maestro has bundled CLI control plus a separate read-only documentation-search MCP server.
- Maestro inherits MCP tools, skills and authentication from configured coding providers.
- Group Chat queues busy agents by default, with an explicit unsafe concurrent-edit alternative.
- Group Chat has a moderator, follow-up rounds and named local/remote participants.
- Nested worktree agents expose parent relationships; the fleet fixture remains untested.
- Worktree setup scripts prepare missing files before agents start.
- Group Chat queues busy agents and exposes explicit queue pause/resume.
- Git menus and keyboard shortcuts expose diff and commit context.
- Maestro documents cross-platform desktop and phone-browser control.
- At v1.0.4 Maestro drives eleven coding CLIs as providers: Claude Code, Codex, OpenCode and Factory Droid (fully…
- Provider credentials decide subscription versus API billing.
- The desktop package uses Electron.
- Work starts from prompts or local markdown task documents; Cue reacts to GitHub events and Symphony picks GitHub issues.
- Auto Run uses editable Markdown plans with on-disk checkboxes and resettable run copies.
- Playbooks order documents and worktree agents nest under a parent; no workflow is mandatory.
- File browsing and @ mentions plus image inputs; code search comes from the provider CLI.
- Markdown tasks can be saved and selected before explicit Auto Run.
- Agents create and run Auto Run documents via the CLI; no issue records exist.
- Spec documents persist as markdown files without requirement links.
- Maestro documents multiple agent processes and worktree agents.
- Desktop/SSH execution and headless Cue server pipelines are user-operated.
- Worktree agents use separate directories and branches.
- Maestro documents provider retries, per-run auto-resume caps and stalled-goal/document stops.
- The scoped Web Login uses local username/password accounts.
- Phone access uses a bearer URL token with full host control.
- Another person can drive the same agents through Web Login while the desktop runs; switching providers loses history.
- History links completed Auto Run summaries to sessions and Git tools expose diffs.
- Git menu integrates worktrees, branch changes, push/pull and PR creation.
- History keeps task summaries, sessions, duration and cost; worktree runs can open a PR.
- Maestro root distribution uses AGPL-3.0.
- Maestro is AGPL-3.0 open source and downloaded from GitHub Releases, with no price or paid plan published; model…
- Maestro adds no fixed fee; scenario costs are provider plans or API usage and the user's own compute.
- Maestro is a free AGPL-3.0 desktop download from GitHub Releases for macOS, Windows and Linux (v1.0.4, a full…
- Maestro has no price to disclose; model costs are the providers'.
Sources
Open the Maestro page
Multicafreshness recheckresearch correction22 findings · 78 sources
Findings today
- Web app, Desktop app (macOS, Windows, Linux) and a CLI exist; the iOS client is self-built from source, with no App…
- Multica does not provide model access in the sources read: each coding tool uses the account, subscription or API…
- Connected computers execute local-tool runs while Cloud or self-hosted Multica coordinates them.
- Estimated per-run and per-issue cost appears in the execution log with a cumulative curve, and the CLI reports issue…
- No public price list was found: /pricing renders a not-found page and the site offers Get started, Book a demo and…
- Internal self-hosted software license cost is $0 for one, two or five users.
- Current release is v0.8.1 dated November 6.
- Self-hosting is free for internal use (infrastructure and tool accounts are the user's), the website offers a Start…
- A commercial license for external hosted/embedded use is quote-only.
- The vendor website, the providers table and the install table each list 29 supported coding tools, including…
- Squads provide product-owned delegation: an agent leader receives the issue, @-mentions member agents, records an…
- Execution log exposes run state, timing and streaming transcript with classified failure reasons; a workspace…
- Review is issue- and PR-centric: in_review status, a pull request card with state, size, CI and mergeability,…
- Issues retain comments, attachments with versions, a deliverables sidebar and in-place previews (HTML, Markdown,…
- Multica shows CI status and mergeability on the PR card and can move an issue when linked PRs merge, but no…
- Agents run Git and the GitHub CLI themselves; Multica adds per-task worktrees, a task Git identity, optional…
- Merging is done by humans or by agents on request through the user's own Git tooling; the GitHub App is read-only.
- Workspace owners/admins keep an MCP server library that is assigned per agent and passed to most supported tools;…
- Agent instructions, workspace context, project descriptions and reusable skills provide shared context; sessions…
- Issues have parent-child relationships.
- Issue descriptions can hold persistent requirements editable by people and agents.
- Runs are unsandboxed and tool approval prompts are answered automatically by default; agent Access controls who can…
Sources
Open the Multica page
Omnarafreshness recheckresearch correction46 findings · 19 sources
Findings today
- Client access: The scoped current frontend distribution ships a web dashboard, CLI and SDK, with no native…
- Omnara uses its own model/tool agent loop with configurable model providers.
- Bring API credentials or use managed model credits; native agent subscription reuse is not documented.
- Create agent config and grants, then use dashboard/API/CLI; own machine and full self-host recipes exist.
- Product CLI, REST API, TypeScript SDK and event webhooks operate durable agents.
- Agents can call MCP/custom tools and load versioned skills.
- Client implementation: Pinned source 313ac70: frontend/apps/web is a React and Vite single-page app served by the…
- Agent conversations accept dashboard/API prompts and integration subscriptions.
- Durable task plans: There is no task-plan object; agent configs are immutable and profile updates keep a version…
- Hierarchy, dependencies and evolving scope: Agents can spawn subagents that nest up to max_depth (default 1, at most…
- Agent configs, versioned skills and shared project memory retain context.
- External tools and versioned knowledge packages supply agent context.
- The scoped native database and API manage durable agent conversations and trigger configurations.
- Agent-native issue operations: An agent creates child agents with spawn_agent and reads, messages, stops and lists…
- Product subagents run concurrently within configured caps.
- Product dispatches subagents and leases execution steps to workers.
- Product-owned agents delegate, message/read children and receive their results.
- Omnara control-plane cron schedules (cron plus timezone) and provider events (Slack, Discord, GitHub) start agents…
- Queued/steering inputs, stop and permission interactions control work.
- Instances dashboard filters agent activity and exposes child relationships.
- Reusable profiles and mid-conversation configs customize agent behavior.
- Control plane persists independently of user/BYO or managed execution machines.
- Machine pools can use container sandbox providers (Daytona, Agent37, Modal) or microVM and full-VM providers.
- Durable event state survives workers and machine loss with explicit unknown external outcomes.
- Managed pools include development tools; custom images/snapshots and startup scripts are configurable.
- Model retries/timeouts/context limits and subagent depth caps are explicit.
- Agent activity distinguishes waiting, background processes, idle and archived; history records errors.
- Per-task API and compute cost: Managed machines cost $0.0414 per GiB of memory per hour online plus $0.20016 per GiB…
- Capacity caps and worker leases bound allocation and recovery.
- Authorized project operators can send input to the same durable agent.
- Organization/project roles are documented; SSO is documented for self-hosted deployments and the Enterprise offering.
- Per-tool allow/ask/deny policy creates durable permission interactions.
- Durable event timeline records attributed inputs, config changes and tool outcomes.
- Review experience and guidance: On GitHub PRs agents post discussion and inline review comments, replies and reviews…
- Colleague takeover and continuity: Any project operator can send attributed inputs, resolve approvals and stop work…
- Durable artifacts attach immutable downloadable content to agent events.
- Through the GitHub App integration, an agent assigned to a pull request can read its diff, comments and reviews,…
- Omnara describes the full platform as Apache-2.0 open source.
- Full control plane can run on own database/storage/compute.
- Self-hosting controls data stores; machine deletion does not delete agent history/artifacts.
- Platform has $0 fee; managed model/machine usage is separate.
- Scenario cost and controls: No platform fee and no per-seat fees on Omnara Cloud self-serve; self-hosting is free.
- Current open-source daemon release and cloud/self-host access are documented.
- SOC 2 Type II is in observation, not a completed audit claim.
- Full platform is free with own models/machines and no card.
- Managed usage units/rates are public; Enterprise is contact-priced.
Sources
Open the Omnara page
Omnigentfreshness recheckresearch correction47 findings · 15 sources
Findings today
- Native desktop on three OSs, native phone apps, browser and CLI connect to product server.
- Named coding harnesses support direct/native modes with distinct support levels.
- Use native Claude/ChatGPT subscriptions, API credentials or compatible gateways.
- Local setup or user-hosted server/runner deployment are documented.
- Product CLI and REST API manage sessions, hosts and scheduled tasks.
- YAML agents use MCP/local functions/skills; owner controls live agent configuration.
- Native shells connect to server-served UI; desktop includes Electron browser.
- New-chat prompt creates a persistent session; external links may prefill drafts.
- Polly decomposes tasks; native Plan mode and persistent sessions retain planning context.
- Polly parent-child orchestration decomposes one task into parallel subtasks.
- Server stores skills/bundles/history and YAML defines shared tools/context.
- Custom MCP tools and browser inspection supply external knowledge.
- The scoped native UI and database have agent sessions, project grouping and scheduled automation definitions.
- Agents create child sessions and read other sessions' status and history through built-in tools; Omnigent has no…
- Polly runs several coding agents in parallel.
- Polly routes implementation and review work to child agents.
- Shipped Polly orchestrator delegates inspectable mixed-harness children.
- Persistent recurring automations launch agent sessions from server.
- Shared prompt/approval control and notifications are available across clients.
- Agents panel, project session grouping and attention badges expose running work.
- Single agents, Polly presets and custom YAML define workflows.
- In the self-hosted v0.23.0 release, a separate server and hosts run sessions locally, on user-controlled remote…
- Git worktrees, remote sandbox containers and optional OS policies are separate isolation mechanisms.
- Server persists sessions through restarts; forks copy history with independent compute binding.
- Cloud sandbox configuration and remote SSH host setup are documented.
- Configurable policies cap tool calls and spend with approvals.
- Session state, output and incomplete Git data are visible.
- Spend policies use USD caps; broader billing reconciliation remains unestablished.
- spawn_bounds caps sub-agent dispatches per turn; host resource scheduling and queues were not established.
- Edit collaborators co-prompt the same live session.
- Admin/user management, OIDC SSO and Read/Edit/Owner boundaries are documented.
- Policy/harness gates ask or deny tools; owner controls permission mode.
- Committed session events and authorship persist and export.
- Changes and PR UI support diff review and inline GitHub conversations.
- Teammates co-drive a shared session or fork full history independently.
- Files, diffs, conversation and browser screenshots are accessible.
- Polly routes worker changes to a different-vendor reviewer; policy gates are separately configured.
- GitHub PR association, review and merge controls are documented.
- Product PR panel has merge controls; deployment authority remains unknown.
- Server retains session PR associations even with execution host offline.
- Compact PR list exposes checks/merge state and inline review discussion.
- Omnigent application repository is Apache-2.0.
- Full server/host is self-hostable and sessions export/import JSONL.
- Anonymous telemetry defaults on and has explicit opt-outs; session storage belongs to own server.
- Omnigent's open-source self-hosted distribution is Apache-2.0 with no paid plan or price published; you bring your…
- v0.21.0 is released; public docs and issue support exist.
- Apache application is freely installable/self-hostable; providers and infrastructure cost separately.
Sources
Open the Omnigent page
Onafreshness recheckresearch correction43 findings · 23 sources
Findings today
Sources
Open the Ona page
OpenCoderesearch correctionfreshness recheck39 findings · 22 sources
Findings today
- OpenCode supplies its own harness and a native Claude Agent integration that launches the installed Claude Code…
- The official V2 CLI docs provide a pull-request-triggered GitHub Actions workflow.
- OpenCode has desktop (macOS, Windows, Linux) and terminal clients, a password-protected browser UI and a mobile…
- CLI, SDK/HTTP APIs and stdio ACP expose OpenCode programmatic operations.
- OpenCode documents scoped code search, external retrieval and image/PDF reads.
- opencode reload applies configuration changes to running sessions at the next step boundary; other…
- The OpenCode CLI exposes cost and token statistics; subscription-backed Claude Agent omits monetary cost.
- OpenCode Console has named workspace roles and SSO; local runtime has separate password access.
- OpenCode keeps stored sessions that can be listed, exported as JSON (optionally sanitized) and imported.
- The user-operated runtime (shared or standalone server) supports JSON session export/import, and uninstall keeps…
- OpenCode stores best-effort local snapshots that can contain full file contents; undo does not securely erase them.
- Existing provider/subscription routes coexist with free models and local models.
- OpenCode supports MCP plus package/local plugin extension points.
- The Plan agent limits file edits to plan files; shell commands stay permission-controlled.
- OpenCode supports a local service and a standalone runtime on a user-owned always-on or remote host.
- OpenCode documents best-effort filesystem snapshots with explicit limits.
- OpenCode CLI provides project/model/time usage statistics with JSON output.
- Tool permission policies coexist with password-protected server pairing and durable approvals.
- A custom read-only reviewer profile is documented; this source pass did not establish a delivery gate.
- Undo/redo restores attributed conversation/file changes within documented best-effort scope.
- Core OpenCode is explicitly free.
- OpenCode is explicitly free to use and includes account-free models.
- Docs describe installing the CLI and connecting a provider.
- The pinned desktop package uses Electron and Solid.
- Agent profiles add project instructions and skills.
- The native core implements an experimental per-session todo tool with pending/in-progress/completed/cancelled states…
- Desktop documents agents working concurrently in separate tabs.
- OpenCode supplies a product-owned child-session subagent tool with agent/model selection and follow-ups by session ID.
- Approval requests can be allowed once, saved or rejected.
- Worktree operation is distinct from host-user security permissions.
- Desktop terminals persist while API event streams require resubscription.
- Model steps and transport timeouts are configurable.
- Native clients can access the same OpenCode server, but authentication uses one shared identity.
- Desktop documents diff review and line comments.
- Desktop exposes diffs and an in-app browser.
- The available stable V1 GitHub Action can handle issue/PR comments, implement work on a branch and submit a pull…
- The root source distribution is MIT.
- Desktop README labels the app beta; mobile is an iPhone public TestFlight beta plus an Android app on Google Play.
- OpenCode Console prices hosted model access, not the OpenCode clients: pay-as-you-go models per 1M tokens (images…
Sources
Open the OpenCode page
Archived event links
Something wrong or missing?