Skip to content

AI Coding Agents Arena

Cursor vs Slate

Cursor wins · 3111 (24 drawn)

Agenticness — how well agents can access and operate the productAgenticness

How well agents can access and operate the product

Agent access

  1. ai-native userPoint an agent at llms.txt or agent-oriented docs

    weight 2 · round to Slate
    Cursornone0/10

    No evidence pack item mentions llms.txt, agent-oriented documentation ingestion, or a mechanism to point Cursor's agent at such files; only generic doc/MCP/tooling references are present. missing for 10: any mention of llms.txt support, crawling agent-oriented doc formats, or a documented feature for feeding external agent docs to Cursor's agent.

      Slatefullprobed8/10

      A probe confirms Slate's docs site serves a valid llms.txt at the root with links to actual docs pages, directly satisfying the ability to point an agent at agent-oriented docs. Missing for 10: no independent/community confirmation that agents successfully consume this llms.txt in practice, and no broader agent-oriented doc format beyond the single file.

      • [probe] PROBE llms.txt: HTTP 200 at https://docs.randomlabs.ai/llms.txt # Slate ## Docs - [Introduction](https://docs.randomlabs.ai/en/getting-sta…
    • ai-native userRun the product headlessly / in CI for automation

      weight 2 · round to Cursor
      Cursorpartialprobed6/10

      Cursor ships an official CLI (cursor.com/cli, curl installer) and background/cloud agents that run 'on schedules or triggers' to build and fix software autonomously, which implies non-interactive/headless automation. However, there is no explicit documentation of CI pipeline integration, exit codes, or scripting examples for pipelines. Missing for 10: explicit CI/CD integration docs (e.g., GitHub Actions example), documented headless flags/exit-code behavior, and independent confirmation of CLI use in automated pipelines.

      • [probe] official CLI documented at https://cursor.com/cli
      • [claimed-docs] curl https://cursor.com/install -fsS | bash
      • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
      • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
      Slatenone0/10

      The docs describe Slate as an interactive terminal agent (onboarding, slash commands, hotkeys, subagent cards) with a permission-bypass flag (--dangerously-skip-permissions/--yolo), but there is no mention of a headless mode, non-interactive CLI flags, exit-code/scriptable output, or CI integration examples. Missing for 10: documented headless/non-interactive invocation, CI pipeline examples, scriptable output format, and any evidence of automation use outside the interactive TUI.

      • [claimed-docs] We support `--dangerously-skip-permissions` (alias: `--yolo`) to bypass permission prompts.
      • [claimed-docs] npm i -g @randomlabs/slate
      • [claimed-docs] Use `/sessions` to switch between existing sessions
    • ai-native userPlug MCP servers into this product so it can use their tools

      weight 3 · round to Cursor
      Cursorfullclaimed8/10

      Cursor's docs explicitly describe MCP support: connecting to external tools/data sources, marketplace one-click install with OAuth, custom JSON server configuration, toggling servers, and enterprise admin controls over allowed servers. This directly matches the story of plugging in MCP servers so the agent can use their tools. Missing for 10: independent hands-on verification of MCP tool usage in practice and no community corroboration of the feature's reliability.

      • [claimed-docs] Model Context Protocol (MCP) enables Cursor to connect to external tools and data sources.
      • [claimed-docs] Click "Add to Cursor" on a marketplace entry to install it and authenticate with OAuth.
      • [claimed-docs] Configure custom MCP servers with a JSON file
      • [claimed-docs] Enterprise admins can control which MCP servers users may run from the Cursor dashboard.
      • [claimed-docs] Toggle servers on/off without removing them
      Slatenone0/10

      No evidence in the pack mentions MCP servers or integrating external tool providers into Slate; the docs cover skills, permissions, orchestration, and CLI usage but never MCP support. Missing for 10: any documentation or claim about connecting/plugging in MCP servers, configuring MCP tool sources, or using MCP-provided tools.

      • ai-native userUse an official CLI

        weight 2 · round drawn
        Cursorfullprobed8/10

        Cursor documents an official CLI with an install command (curl https://cursor.com/install) and a dedicated CLI docs page (cursor.com/cli), confirming a first-party terminal tool for AI-native workflows. Missing for 10: independent/hands-on corroboration of CLI capabilities and depth of documentation beyond install instructions.

        • [claimed-docs] curl https://cursor.com/install -fsS | bash
        • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
        • [probe] official CLI documented at https://cursor.com/cli
        Slatefullprobed8/10

        Slate is delivered as an official CLI (npm-installed, terminal-based) with rich first-party docs covering install, sessions, hotkeys, shell execution, and configuration — squarely matching the 'official CLI' story for an AI-native user. Missing for 10: independent/hands-on corroboration of the CLI experience itself (community evidence found only relates to unrelated porting-quality claims, not CLI usage).

        • [claimed-docs] npm i -g @randomlabs/slate
        • [claimed-docs] Use `/sessions` to switch between existing sessions
        • [claimed-docs] Press Tab to queue the current message so it runs after the current turn finishes.
        • [claimed-docs] Execute shell commands directly with `!`
        • [claimed-docs] Ctrl+X then N New session
        • [probe] official CLI documented at https://docs.randomlabs.ai/en/getting-started/quickstart
      • ai-native userDrive the product through a documented public API

        weight 3 · round to Cursor
        Cursorpartialprobed3/10

        Evidence shows an official CLI (cursor.com/cli) that lets users invoke Cursor from scripts, which partially satisfies 'driving the product programmatically,' but there is no documented public REST/SDK API, authentication scheme, or endpoint reference — MCP docs describe Cursor consuming external tools, not exposing itself as an API. Missing for 10: documented REST/GraphQL API, SDK/client libraries, API authentication and rate-limit docs, independent corroboration of programmatic usage.

        • [probe] official CLI documented at https://cursor.com/cli
        • [claimed-docs] curl https://cursor.com/install -fsS | bash
        Slatenone0/10

        Slate is documented as a CLI/terminal agent with configuration, skills, and hotkeys, but there is no evidence of a documented public API for programmatic/agentic access—the OpenAPI probe returned 404 across all candidate paths and no SDK or REST/API docs are mentioned anywhere in the pack.

        • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
        • [probe] PROBE llms.txt: HTTP 200 at https://docs.randomlabs.ai/llms.txt # Slate ## Docs - [Introduction](https://docs.randomlabs.ai/en/getting-sta…
      • ai-native userIssue scoped/least-privilege API credentials for an agent

        weight 2 · round drawn
        Cursornone0/10

        No evidence Cursor lets users mint scoped or least-privilege API credentials for agents; docs cover MCP server toggling and enterprise admin control of which servers can run, but nothing about issuing scoped/limited API keys or credentials specifically for agent use.

          Slatenone0/10

          Slate is a coding-agent CLI; its evidence only covers permission settings (allow/ask/deny) for tool actions, not issuance of scoped/least-privilege API credentials or tokens for agents. No mention of credential/token scoping, API key generation, or IAM-style access control.

          • [claimed-docs] Each permission key maps to an action ("allow", "ask", or "deny"), or a pattern object for fine-grained control.
          • [claimed-docs] We support `--dangerously-skip-permissions` (alias: `--yolo`) to bypass permission prompts.
        • ai-native userBuild against official SDKs

          weight 2 · round drawn
          Cursornone0/10

          Evidence shows Cursor offers a CLI, MCP integration, and marketplace extensions, but there is no mention of any official SDK (e.g., a documented library/API package) for developers to build against Cursor itself.

            Slatenone0/10

            The evidence pack covers Slate's CLI, skills, configuration, and orchestration features but contains no mention of an official SDK (Python/TypeScript/etc.) for building applications on top of Slate, and the OpenAPI probe returned 404s across all candidate paths. Missing for 10: any documented SDK package, API reference, or programmatic interface for building against Slate.

            • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
            • [claimed-docs] npm i -g @randomlabs/slate

          Agentic features

          1. ai-native userGet AI-generated insights and suggestions from my data inside the product

            weight 2 · round to Cursor
            Cursorfullclaimed7/10

            Cursor's core value proposition is analyzing the user's codebase to surface AI-generated insights (tracing repo structure, finding root causes, reviewing diffs) and suggestions for next actions, as documented across multiple first-party docs. Missing for 10: independent/hands-on evidence validating the accuracy or depth of these insights, and no detail on insight types beyond code-centric suggestions (e.g., data analytics or business data outside code).

            • [claimed-docs] Trace how a repo fits together and find the right places to start
            • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence
            • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
            • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge

            Slate is a coding-agent CLI whose evidence shows it can analyze a codebase and produce suggestions (e.g., generating an ARCH.md with improvement ideas), which maps loosely to 'AI-generated insights from data' but only in the narrow sense of source code, not general data analysis. Community evidence also raises skepticism about the real quality of generated output (e.g., criticism of a ported-code example as low quality/unverified). Missing for 10: evidence of insights/suggestions over non-code datasets, dashboards or analytics-style outputs, and independent validation of suggestion quality.

            • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
            • [community] Blog post claimed porting a library with one sentence, but critic noted it was JS->TS (trivial rename) not Python->TS, excluded tests/exampl…
            • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…
          2. ai-native userSet up automations that run autonomously in the background

            weight 2 · round to Cursor
            Cursorfullclaimed8/10

            Cursor explicitly documents 'always-on agents that run on schedules or triggers to build, maintain, and fix your software' and 'fleets of agents that work in parallel for hours or days,' directly matching autonomous background automation. This is first-party vendor documentation without independent hands-on corroboration of scheduling/triggers working reliably. Missing for 10: independent/community verification that scheduled/triggered background agents work reliably in practice, and more detail on trigger configuration options.

            • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
            • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
            • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

            Slate supports background subagents, parallel task orchestration, and built-in workflows like goal/deep-research that run while the user keeps interacting, which shows some autonomous background execution. However, this is task-level parallelism within an active session, not scheduled or trigger-based automations that run independently of user presence. missing for 10: evidence of scheduled/cron-like automations, persistent background jobs surviving session end, or trigger-based (event-driven) autonomous runs without an active user session.

            • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
            • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
            • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.
          3. ai-native userDelegate tasks to a built-in AI assistant inside the product

            weight 3 · round to Cursor
            Cursorfullclaimed9/10

            Cursor's docs clearly describe delegating tasks to built-in agents that plan, code, test, and demo work end-to-end while the user focuses on review/decisions, including background/parallel agents and always-on scheduled agents. This is a core, heavily documented capability of the product, though independent hands-on validation of agent task quality is thin (only general community commentary, some critical, exists). Missing for 10: deeper independent verification of agent task success rates beyond vendor docs.

            • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
            • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
            • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
            • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
            • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence

            Slate is a CLI-based AI assistant where users delegate whole tasks (e.g., 'review architecture and write ARCH.md') and it spins up parallel subagents, orchestration programs like goal/deep-research, and long multi-hour sessions per first-party docs. Community evidence (comm-1/2/3) raises skepticism about output quality/novelty but does not contradict the core delegation mechanism itself. Missing for 10: independent hands-on validation that delegated multi-agent tasks reliably complete as advertised.

            • [claimed-docs] Parallelize working and orchestration of many tasks at once.
            • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
            • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
            • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
            • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.
            • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…
          4. ai-native userOperate the product with natural-language commands

            weight 2 · round to Cursor
            Cursorfullclaimed8/10

            Cursor's core interaction model is natural-language driven agents that plan, code, test, and operate across terminal/Slack/GitHub (cursor-docs-2, cursor-docs-8, cursor-docs-9, cursor-docs-10, cursor-docs-11), consistent with an AI-native product. Missing for 10: independent hands-on evidence specifically validating natural-language command reliability/accuracy (community evidence focuses on bugginess/pricing complaints unrelated to NL command capability itself).

            • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence
            • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
            • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
            • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
            • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
            • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

            Docs show Slate is driven primarily via natural-language prompts (e.g. the quickstart example 'Please review the architecture of my entire codebase...') alongside slash-commands, shell escapes, and file references, indicating natural-language is the core interaction mode for an AI-native agent CLI. Missing for 10: independent/hands-on confirmation that complex natural-language commands are reliably parsed and executed as intended (community evidence only discusses code-porting quality, not NL command usage itself).

            • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
            • [claimed-docs] Execute shell commands directly with `!`
            • [claimed-docs] Use `@filename` references
            • [claimed-docs] Use `/sessions` to switch between existing sessions
            • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.

          Api quality

          1. ai-native userDownload a machine-readable API spec (OpenAPI or equivalent)

            weight 2 · round drawn
            Cursornone0/10

            No evidence of Cursor publishing a downloadable OpenAPI or equivalent machine-readable API spec; docs reference MCP config and CLI but not an API spec.

              Slatenone0/10

              Slate's docs site was directly probed for an OpenAPI/swagger spec at standard locations and all returned 404, and no documentation anywhere mentions a machine-readable API spec for AI-native consumption.

              • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
            • ai-native userRely on versioned APIs with a documented deprecation policy

              weight 2 · round drawn
              Cursornone0/10

              No evidence in the pack mentions API versioning or a deprecation policy for Cursor's APIs (CLI, extensions, or MCP config); docs cover features like MCP setup, agents, and integrations but nothing about version stability guarantees or deprecation timelines.

                Slatenone0/10

                Slate is a CLI coding agent product; no evidence of any versioned public API, API reference, or deprecation policy documentation exists—openapi probes returned 404 and no docs mention API versioning or deprecation. Absence of evidence for this applicable axis (a product could plausibly document API stability) yields 'none'.

                • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…

              Automation depth — how much of the product can run unattendedAutomation depth

              How much of the product can run unattended

              1. ai-native userPerform bulk operations across many items at once

                weight 2 · round to Slate
                Cursorpartialclaimed5/10

                Cursor supports launching 'fleets of agents' in parallel and always-on scheduled/triggered agents, which enables some multi-item automation, but there's no direct evidence of bulk operations across many discrete items (e.g., bulk file edits, batch refactors, or multi-repo operations) as a first-class feature. missing for 10: explicit documentation or hands-on evidence of bulk/batch operations across many items (files, tickets, repos), user-facing UI for selecting many items at once, and independent corroboration of this working in practice.

                • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.

                Docs describe running many agents in parallel and orchestrating multiple tasks simultaneously (grid of subagent cards, spinning up more agents to parallelize work), which supports bulk-style operations across many items. However, there's no independent corroboration of this working at scale and no detail on failure handling, limits, or item-level bulk operations (e.g., bulk file edits/refactors) beyond task orchestration. Missing for 10: independent/hands-on verification of large-scale parallel task execution, concrete examples of bulk item processing (files/records), and failure/error handling details at scale.

                • [claimed-docs] Parallelize working and orchestration of many tasks at once.
                • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.
              2. ai-native userDefine rules that trigger actions automatically on events

                weight 3 · round to Cursor
                Cursorpartialclaimed6/10

                Cursor docs describe 'always-on agents that run on schedules or triggers' and a way to 'add rules' from one place, matching the idea of rule-based automation triggered by events. However the evidence pack doesn't detail how rules are authored/scoped to specific events beyond the marketing blurb, and there's no independent/hands-on confirmation of this automation working as described. Missing for 10: concrete rule-definition syntax/examples, independent verification that scheduled/triggered agents reliably fire on events, and detail on event types supported.

                • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                • [claimed-docs] Add plugins, skills, MCPs, and rules from one place
                Slatenone0/10

                Slate's docs describe agent rules for permissions/behavior ordering (docs-15, docs-20) and orchestration of parallel agents (docs-12, docs-13), but there is no evidence of user-defined rules that trigger actions automatically on external events (e.g., file changes, webhooks, schedule, git events). This is a plausible axis for a coding agent (many support hooks/triggers), so absence of evidence yields none rather than na.

                • [claimed-docs] Slate by default respects agent rules in the following order
                • [claimed-docs] Each permission key maps to an action ("allow", "ask", or "deny"), or a pattern object for fine-grained control.
              3. ai-native userSchedule recurring jobs or workflows

                weight 2 · round to Cursor
                Cursorfullclaimed7/10

                Cursor documents 'always-on agents that run on schedules or triggers to build, maintain, and fix your software,' directly matching recurring scheduled workflow automation, alongside parallel agent fleets for ambitious tasks. Missing for 10: independent hands-on verification of scheduling reliability, details on trigger configuration options, and any community corroboration of this specific feature working in practice.

                • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                Slatenone0/10

                Slate is a coding-agent CLI with orchestration/parallel-agent features and sessions, but nothing in the evidence describes scheduling recurring jobs or workflows (e.g., cron-like triggers, timed recurring runs). Orchestration docs cover on-demand parallelization, not recurrence.

                • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.
              4. ai-native userVersion, review, and roll back my automations

                weight 1 · round drawn
                Cursornone0/10

                Evidence shows Cursor can inspect diffs and review changes before merge, but there is no documented capability to version, review, or roll back the automations themselves (e.g., scheduled/always-on agents, rules, MCP configs) as distinct artifacts with history/rollback support.

                  Slatenone0/10

                  Evidence shows session management (/sessions, /workspace) and built-in 'programs' like goal/deep-research, but nothing about versioning automations, reviewing history of changes, or rolling back to prior states of an automation/workflow. Missing for 10: any documentation of version history, diffing, or rollback mechanisms for automations/workflows.

                  • [claimed-docs] Use `/sessions` to switch between existing sessions
                  • [claimed-docs] Use `/workspace` to open the workspace manager, where you can review and remove workspace directories.
                  • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.

                Autonomy agents — stories about autonomy agents in this arenaAutonomy agents

                Stories about autonomy agents in this arena

                Background execution

                1. ai-native userHave a cloud agent build, test, and demo a feature end-to-end for my review

                  weight 2 · round to Cursor
                  Cursorfullclaimed7/10

                  Cursor's docs explicitly describe cloud/background agents that 'use their own computers to build, test, and demo features end to end for you to review,' plus the ability to launch fleets of agents working in parallel for hours/days, and always-on scheduled agents — directly matching the story. Corroboration is entirely first-party marketing/docs rather than independent hands-on verification of an actual demo workflow. Missing for 10: independent/hands-on evidence confirming the build-test-demo loop works reliably end-to-end, and detail on what 'demo' concretely produces (e.g., preview links, recordings).

                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                  Slate's docs claim orchestration of parallel background subagents and being 'one of the few agents capable of performing integration tests manually,' suggesting it could build and test a feature autonomously, but no docs mention a 'demo' output or cloud-hosted execution environment. Community hands-on critique of an actual Slate-produced port directly contradicts the build/test claim: reviewers found the work excluded tests/examples and provided no verifiable repo, undermining confidence that Slate reliably builds+tests end-to-end for review. Missing for 10: evidence of cloud/remote execution infra, an explicit demo-generation feature, and independent confirmation that test suites are actually run and pass.

                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                  • [claimed-docs] Slate is one of the few agents capable of performing integration tests manually.
                  • [community] Blog post claimed porting a library with one sentence, but critic noted it was JS->TS (trivial rename) not Python->TS, excluded tests/exampl…
                  • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…
                2. developerDelegate longer-running coding tasks to run in the background in an isolated cloud environment

                  weight 3 · round to Cursor
                  Cursorfullclaimed8/10

                  Cursor documents cloud/background agents ('Agents use their own computers to build, test, and demo features end to end', 'Launch fleets of agents that work in parallel on ambitious tasks for hours or days', and hand-off delegation while the developer focuses elsewhere), matching the isolated cloud-background-task story. Missing for 10: independent hands-on verification of the background agent's isolation/reliability and details on session duration limits or failure modes.

                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                  Slatenone0/10

                  Slate's docs describe subagents running 'in the background' locally while you keep chatting and orchestration/parallelization of tasks, but there is no mention of an isolated cloud environment, remote execution sandbox, or delegation to a hosted service — everything described appears to run within the local CLI session. This axis is applicable to coding agent tools generally, but no evidence supports a cloud-isolated background execution capability for Slate.

                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                  • [claimed-docs] Slate works with you across long, multi-hour sessions.
                  • [claimed-docs] Parallelize working and orchestration of many tasks at once.
                3. developerConfigure a reproducible cloud environment with the dependencies and setup steps my repository needs

                  weight 2 · round to Cursor
                  Cursorpartialclaimed4/10

                  Cursor's docs mention cloud/background agents that 'use their own computers to build, test, and demo features' and can be launched in fleets or run on schedules, implying some cloud execution environment, but there's no evidence pack detail on how a developer configures dependencies, install scripts, or a reproducible environment spec (e.g. Dockerfile/environment.json) for these agents. Missing for 10: explicit documentation of environment configuration format, dependency/setup step definition, and evidence of reproducibility across runs.

                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                  Slatenone0/10

                  Slate's docs describe a local CLI agent (npm install, terminal sessions, permissions, skills, orchestration) but contain no mention of provisioning or configuring a reproducible cloud environment, dependency setup, or devcontainer-style configuration for a repository. This is a fair capability to ask of an autonomous coding agent, but no evidence shows Slate supports it.

                  • [claimed-docs] npm i -g @randomlabs/slate
                  • [claimed-docs] Slate by default respects agent rules in the following order
                  • [claimed-docs] Each permission key maps to an action ("allow", "ask", or "deny"), or a pattern object for fine-grained control.

                Parallel agents

                1. ai-native userLaunch fleets of autonomous agents that work in parallel on different tasks for hours or days

                  weight 2 · round to Cursor
                  Cursorfullclaimed8/10

                  First-party marketing/docs explicitly state the exact capability: "Launch fleets of agents that work in parallel on ambitious tasks for hours or days," plus supporting evidence of background/always-on agents and agents using their own compute to build/test/demo. No independent hands-on verification of multi-day parallel fleet execution is present, and no community corroboration confirms this specific feature works at scale. Missing for 10: independent/hands-on validation of parallel agent fleets running for hours/days, details on concurrency limits or reliability over long runs.

                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.

                  Docs describe genuine parallel agent orchestration (grid of subagent cards, spinning up more agents while others run in background) and explicitly support multi-hour sessions, matching much of the story. However, evidence only confirms 'multi-hour' not multi-day autonomy, and community commentary raises skepticism about output quality/novelty without directly refuting the parallel-agent mechanics themselves. Missing for 10: confirmation of multi-day unattended runs, independent hands-on validation of fleet-scale parallel task completion.

                  • [claimed-docs] Slate works with you across long, multi-hour sessions.
                  • [claimed-docs] Parallelize working and orchestration of many tasks at once.
                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                  • [community] Commenter compared the approach to 'Ralph as a service' referencing an existing agentic coding technique (ghuntley.com/ralph), suggesting Sl…
                2. developerRun several task attempts in parallel and compare results before choosing one

                  weight 1 · round drawn
                  Cursorpartialclaimed6/10

                  Cursor's docs describe launching 'fleets of agents that work in parallel on ambitious tasks for hours or days,' directly supporting parallel task execution, and agents run in isolated environments for review before merging changes. However, there is no explicit documentation of a UI/workflow for comparing multiple parallel attempts side-by-side before choosing one, and no independent/hands-on evidence corroborating this specific comparison workflow. Missing for 10: dedicated compare/diff-across-attempts feature documentation, independent verification of parallel-agent comparison in practice.

                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                  Slate's orchestration docs show multiple subagents running in parallel as a grid of cards while the user keeps working, directly supporting parallel task execution (docs-12, docs-13). However, there's no explicit documentation of a compare/diff view or a 'choose winning attempt' workflow for reconciling multiple parallel results into one choice. Missing for 10: explicit comparison/selection UI or workflow for multiple attempts of the same task, and independent/hands-on confirmation of this specific use case.

                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                  • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.

                Scheduled automation

                1. ai-native userSet up always-on agents that run on schedules or triggers to maintain and fix my software autonomously

                  weight 2 · round to Cursor
                  Cursorfullclaimed8/10

                  Cursor's own site directly states the capability: "Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software," plus related background-agent features (parallel fleets, agents running on their own machines) that support this workflow. Missing for 10: independent/hands-on confirmation of scheduled/triggered agents actually running reliably in practice, and more detail on trigger types/configuration.

                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                  Slatenone0/10

                  Slate's docs describe parallel subagent orchestration within a live session (background agents you keep talking to, spin up more agents to parallelize tasks) but there is no evidence of scheduling, event/webhook triggers, or persistent always-on agents that run autonomously outside an active session to maintain/fix software over time.

                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                  • [claimed-docs] `goal` and `deep-research` are built-in programs. They are user-visible workflows, not something you need to author before using Slate.

                Code generation — quality of generated code — correctness, style, fit to the codebaseCode generation

                Quality of generated code — correctness, style, fit to the codebase

                Debugging

                1. developerDebug a live running web application directly from my coding assistant

                  weight 1 · round drawn
                  Cursornone0/10

                  No evidence pack item describes attaching a debugger, inspecting runtime state, or interacting with a live running web app from Cursor; docs mention reproducing issues and root-causing bugs conceptually, but not live-app debugging integration (e.g., breakpoints, browser dev tools, runtime inspection). missing for 10: evidence of live debugger attach/breakpoints, browser/runtime inspection tooling, or integration with running app state.

                  • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                  • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                  Slatenone0/10

                  No evidence in the pack mentions debugging live running applications, attaching to running processes, browser/runtime debugging, or any live-app inspection capability; Slate's docs focus on codebase review, shell commands, orchestration, and skills, none of which address live debugging.

                  • developerDebug issues and troubleshoot using natural-language queries

                    weight 2 · round to Cursor

                    cursor-docs-3 directly claims support for reproducing issues, narrowing root cause, and verifying fixes via natural-language-driven agent workflows, and docs-1 supports tracing how a repo fits together to find bug locations. However, there's no independent/hands-on evidence corroborating debugging quality, and community evidence highlights buginess and unreliability concerns (cursor-comm-2, cursor-comm-8) that add caveats without directly contradicting the specific debugging workflow claim. Missing for 10: independent verification of debugging accuracy, concrete examples of NL-driven troubleshooting sessions, and resolution of buggy-product complaints.

                    • [claimed-docs] Trace how a repo fits together and find the right places to start
                    • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                    • [community] "Cursor is weird. They have a basically unused GitHub with a thousand unanswered Issues. It's so buggy in ways that VSCode isn't. I hate it.…
                    • [community] "That's a lot of money for a buggy product that is at best slightly better than its competitors."

                    Slate's docs show it operates via natural-language prompts, executes shell commands (`!`), references files (`@filename`), and can run integration tests and review codebase architecture in NL form, which implies it could be used for debugging and troubleshooting queries. However there is no explicit example, workflow, or documentation section dedicated to debugging/troubleshooting via natural language, and community evidence is skeptical/unrelated to this specific capability. Missing for 10: explicit debugging-focused examples or docs, independent verification that NL-based debugging works well, dedicated troubleshooting workflow beyond generic agent capabilities.

                    • [claimed-docs] Execute shell commands directly with `!`
                    • [claimed-docs] Use `@filename` references
                    • [claimed-docs] Slate is one of the few agents capable of performing integration tests manually.
                    • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.

                  Feature implementation

                  1. developerTurn a tracked issue into a complete pull request end-to-end

                    weight 3 · round to Cursor
                    Cursorpartialclaimed7/10

                    Cursor's docs describe agents that trace repos, plan changes, reproduce issues, inspect diffs/run checks, and integrate with issue trackers (GitHub, Linear) and PR review, which together support a full issue-to-PR workflow (cursor-docs-1 through cursor-docs-4, cursor-docs-6, cursor-docs-8–cursor-docs-12). However, there's no explicit first-party or independent case study showing a single tracked issue being turned into a merged PR end-to-end without manual intervention, and community evidence focuses on unrelated bugs/pricing complaints rather than this workflow. Missing for 10: a concrete end-to-end example/case study of issue→PR automation and independent verification that the full pipeline works reliably.

                    • [claimed-docs] Trace how a repo fits together and find the right places to start
                    • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence
                    • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                    • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                    • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                    • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                    • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                    • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                    • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                    • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                    Slatenone0/10

                    The evidence pack covers Slate's session management, orchestration, skills, and permissions but contains no mention of issue-tracker integration (e.g., GitHub issues) or automated pull-request creation/submission. Without evidence of ingesting a tracked issue and producing a PR end-to-end, this capability is unshown.

                    • developerDescribe a feature or bug in plain language and have the agent implement or fix it across multiple files

                      weight 3 · round to Cursor

                      Cursor's docs describe an agent that traces repo structure, plans and scopes multi-file changes, implements features/fixes end-to-end, runs checks, and produces diffs for review — directly matching plain-language feature/bug requests across multiple files. Community evidence corroborates the product is used daily for this purpose (albeit with complaints about bugginess), without disputing the core multi-file agentic editing capability. Missing for 10: independent hands-on benchmarks showing successful multi-file fixes, and no first-party demo/case study detailing a concrete before/after example.

                      • [claimed-docs] Trace how a repo fits together and find the right places to start
                      • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence
                      • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                      • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                      • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                      • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                      • [community] "Cursor is weird. They have a basically unused GitHub with a thousand unanswered Issues. It's so buggy in ways that VSCode isn't. I hate it.…
                      • [community] "That's a lot of money for a buggy product that is at best slightly better than its competitors."

                      Docs imply broad multi-file code work (e.g. the quickstart example asks Slate to review an entire codebase and produce ARCH.md, plus orchestration features for parallelizing tasks across files/agents), suggesting Slate can act on plain-language requests across a codebase. However, independent community scrutiny of a specific real-world claim (a 'ported library' from one sentence) found it was actually a trivial JS->TS rename, excluded tests, lacked a verifiable repo, and drew explicit skepticism about the quality/usefulness of the generated code — concretely contradicting the marketed multi-file code-generation capability. Missing for 10: first-party documentation of a genuine multi-file bug-fix/feature-implementation workflow with verifiable before/after results, and independent hands-on confirmation that resolves the community dispute.

                      • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
                      • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                      • [claimed-docs] Parallelize working and orchestration of many tasks at once.
                      • [community] Blog post claimed porting a library with one sentence, but critic noted it was JS->TS (trivial rename) not Python->TS, excluded tests/exampl…
                      • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…

                    Maintenance automation

                    1. developerHave the agent write tests, fix lint errors, resolve merge conflicts, and update dependencies for me

                      weight 3 · round to Cursor
                      Cursorpartialclaimed6/10

                      Cursor's docs describe agents that write code, run tests/checks, and 'build, maintain, and fix' software autonomously (cursor-docs-3, cursor-docs-4, cursor-docs-9, cursor-docs-12), which implies test-writing and general maintenance tasks, but there is no explicit documentation of lint-error fixing, merge-conflict resolution, or dependency-update workflows specifically. missing for 10: explicit lint-fixing examples, explicit merge-conflict-resolution examples, explicit dependency-update examples, independent hands-on verification of these specific tasks.

                      • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                      • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                      • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                      • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                      Slate is documented as a general-purpose coding agent with shell execution, file editing, permissioning, and orchestration of multiple sub-agents (random-labs-docs-9, random-labs-docs-13, random-labs-docs-16), which implies it could perform tasks like running tests or lint/dependency commands, but the evidence never explicitly documents test-writing, lint-fixing, merge-conflict resolution, or dependency updates as capabilities. Community commentary raises quality concerns about generated code but doesn't specifically address these tasks. Missing for 10: explicit documentation or examples of writing/fixing tests, resolving lint errors, resolving merge conflicts, and updating dependencies.

                      • [claimed-docs] Execute shell commands directly with `!`
                      • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                      • [claimed-docs] Slate is one of the few agents capable of performing integration tests manually.
                      • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…

                    Multimodal generation

                    1. ai-native userGenerate a working app from a sketch, image, or PDF design

                      weight 2 · round drawn
                      Cursornone0/10

                      No evidence in the pack describes image/sketch/PDF-to-app generation, multimodal design input, or any UI-from-design workflow; the docs snippets cover repo navigation, plan mode, agents, MCP, and integrations but nothing about visual design inputs.

                        Slatenone0/10

                        The evidence describes Slate as a terminal-based CLI agent for coding sessions, orchestration, skills, and permissions, but nothing in the docs or community evidence mentions accepting sketches, images, or PDF designs as input to generate an app. missing for 10: any mention of image/sketch/PDF input, multimodal design-to-code capability, or UI mockup ingestion.

                        • [claimed-docs] npm i -g @randomlabs/slate
                        • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
                        • [claimed-docs] Skills are markdown instruction packages that give the agent domain-specific knowledge and behavior.
                        • [claimed-docs] description: "Create distinctive, production-grade frontend interfaces."

                      Codebase understanding — how deeply the tool maps your repo — cross-file context, architecture awareness, historyCodebase understanding

                      How deeply the tool maps your repo — cross-file context, architecture awareness, history

                      Codebase mapping

                      1. developerUnderstand how a codebase fits together to find where to start making changes

                        weight 3 · round to Cursor
                        Cursorpartialclaimed6/10

                        Cursor's docs explicitly claim the ability to 'trace how a repo fits together and find the right places to start,' directly matching the story, but this is a single marketing-style doc line with no detailed walkthrough, feature docs (e.g., codebase indexing/@codebase chat), or independent corroboration of how it actually surfaces architecture understanding. Missing for 10: detailed documentation of the codebase-mapping/indexing feature itself, concrete examples of it locating relevant code, and independent/hands-on validation of accuracy.

                        • [claimed-docs] Trace how a repo fits together and find the right places to start

                        The quickstart example explicitly shows Slate producing an ARCH.md architecture review of an entire codebase with improvement suggestions, directly supporting codebase-understanding use cases, and @filename references plus workspace management help navigate a repo. However there's no dedicated codebase-mapping/search feature (e.g., symbol index, dependency graph) documented beyond this one example, and no independent evidence confirming quality of such architecture summaries. missing for 10: dedicated code-navigation/search tooling, independent validation of architecture-summary accuracy, more than a single example of codebase-understanding workflow.

                        • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
                        • [claimed-docs] Use `@filename` references
                        • [claimed-docs] Use `/workspace` to open the workspace manager, where you can review and remove workspace directories.
                      2. developerHave the agent map and explain an entire unfamiliar codebase without manually selecting context files

                        weight 3 · round to Slate
                        Cursorpartialclaimed4/10

                        First-party docs claim Cursor can 'trace how a repo fits together and find the right places to start' (cursor-docs-1), implying automatic codebase mapping, but there's no detail on how context is auto-gathered (e.g., codebase indexing/@codebase) nor any independent/hands-on confirmation that it explains an unfamiliar codebase without manual file selection. Missing for 10: technical explanation of automatic context retrieval, independent user validation of whole-codebase explanation, and comparison to manual context selection workflows.

                        • [claimed-docs] Trace how a repo fits together and find the right places to start

                        Docs show Slate's quickstart example explicitly demonstrates asking it to 'review the architecture of my entire codebase' and generate an ARCH.md without manual file selection, and it has orchestration/subagent features for broad exploration. However there's no independent/hands-on verification that this codebase-mapping actually works well on large unfamiliar repos, and community evidence raises quality skepticism about other generated outputs. missing for 10: independent hands-on validation of full-codebase mapping accuracy, evidence of handling very large/unfamiliar codebases without manual curation, detail on how context is auto-selected under the hood.

                        • [claimed-docs] Please review the architecture of my entire codebase creating an ARCH.md and then give me ways I can improve it.
                        • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                        • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                        • [community] "Why trumpet code that is so ready for the garbage that you wouldn't even bother to publish it" - skepticism about the quality/usefulness of…

                      Context management

                      1. developerHave the agent build and recall memory automatically across sessions

                        weight 2 · round drawn
                        Cursornone0/10

                        No evidence describes persistent memory that automatically builds and recalls context across sessions; docs mention repo tracing, plan mode, and MCP integrations but nothing about cross-session memory recall.

                          Slatenone0/10

                          Docs describe session switching (/sessions), long multi-hour session support, and diagnostic context attachment, but there is no evidence of automatic cross-session memory building or recall — sessions appear to be manually selected/switched contexts, not an automatic memory system. Missing for higher verdict: any documentation of persistent memory storage, automatic recall of past codebase context, or memory summarization across sessions.

                          • [claimed-docs] Slate works with you across long, multi-hour sessions.
                          • [claimed-docs] Use `/sessions` to switch between existing sessions
                          • [claimed-docs] Slate automatically attaches relevant diagnostic information (OS, version, session context) to your report.
                        • developerInclude multiple project directories in a single session for broader context

                          weight 2 · round to Slate
                          Cursornone0/10

                          No evidence in the pack mentions multi-root workspaces or including multiple project directories in a single Cursor session; docs cover repo navigation, MCP, agents, and integrations but not multi-directory context.

                            Docs mention a `/workspace` manager for reviewing and removing 'workspace directories' (plural), implying support for multiple project directories in one session, but there's no detailed documentation on how directories are added or how context is merged across them, and no independent/hands-on confirmation. Missing for 10: explicit instructions/examples for adding multiple directories, and independent verification that broader multi-directory context actually works in practice.

                            • [claimed-docs] Use `/workspace` to open the workspace manager, where you can review and remove workspace directories.
                          • developerAdd a project instructions file to set coding standards and conventions the agent follows

                            weight 3 · round to Slate
                            Cursorpartialclaimed3/10

                            Cursor's docs mention adding 'rules' as one of its features (alongside plugins, skills, MCPs) which aligns with the project-instructions concept, but the evidence pack gives no detail on how project rule files work, their scope, or how the agent applies them to enforce coding standards. missing for 10: documentation of the rules file format/location, examples of coding standards enforcement, independent confirmation the agent actually follows these instructions consistently.

                            • [claimed-docs] Add plugins, skills, MCPs, and rules from one place

                            Docs confirm Slate 'respects agent rules' in a defined precedence order and supports Skills (markdown instruction packages, including Claude Code-compatible `.claude/skills/` paths), which cover project-level conventions/instructions, but there's no explicit example of a single top-level 'instructions file' analogous to AGENTS.md/CLAUDE.md being demonstrated end-to-end. missing for 10: explicit naming/format of the project instructions file, a worked example showing the agent following custom conventions from it, and independent/community confirmation it works as documented.

                            • [claimed-docs] Slate by default respects agent rules in the following order
                            • [claimed-docs] Skills are markdown instruction packages that give the agent domain-specific knowledge and behavior.
                            • [claimed-docs] `.claude/skills/` | Claude Code compatibility

                          Issue diagnosis

                          1. developerReproduce issues, narrow down root causes, and verify fixes

                            weight 3 · round to Cursor
                            Cursorpartialclaimed6/10

                            cursor-docs-3 directly claims the exact capability ('Reproduce issues, narrow the root cause, and verify the fix'), and supporting docs on codebase tracing, diffs/checks, and agents running their own environments (cursor-docs-1, cursor-docs-4, cursor-docs-12) plausibly back this workflow. However, this is a first-party marketing/docs claim only, with no independent or hands-on corroboration of actual debugging workflows, and community evidence highlights general bugginess/quality concerns rather than validating this specific capability. Missing for 10: independent verification or hands-on case studies of reproduce/root-cause/verify-fix workflows, more detail on how reproduction (e.g., test running, log inspection) is concretely supported.

                            • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                            • [claimed-docs] Trace how a repo fits together and find the right places to start
                            • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                            • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                            Slate documents shell execution (`!`), file references, and being 'one of the few agents capable of performing integration tests manually,' which are plausible building blocks for debugging workflows, but there's no explicit documentation of a reproduce→diagnose→verify-fix workflow. Missing for 10: explicit debugging/root-cause-analysis workflow documentation, evidence of test-driven verification loops, and independent hands-on confirmation that Slate helps developers actually reproduce and fix bugs.

                            • [claimed-docs] Slate is one of the few agents capable of performing integration tests manually.
                            • [claimed-docs] Execute shell commands directly with `!`
                            • [claimed-docs] Use `@filename` references
                            • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…

                          Ecosystem — integrations, plugins, and third-party ecosystem storiesEcosystem

                          Integrations, plugins, and third-party ecosystem stories

                          Marketplace

                          1. developerEquip the agent with custom skills to perform specialized tasks

                            weight 1 · round to Slate
                            Cursorpartialclaimed6/10

                            Cursor's docs mention a marketplace to 'Add plugins, skills, MCPs, and rules from one place' and detailed MCP support (custom servers, marketplace install, enterprise controls), enabling developers to extend the agent with specialized tool integrations. However, there's no dedicated documentation on a 'skills' framework distinct from MCP/rules, no examples of custom skill creation workflow, and no independent/community corroboration of this specific capability. Missing for 10: detailed skills documentation/tutorial, examples of custom skill authoring, independent hands-on validation.

                            • [claimed-docs] Add plugins, skills, MCPs, and rules from one place
                            • [claimed-docs] Model Context Protocol (MCP) enables Cursor to connect to external tools and data sources.
                            • [claimed-docs] Click "Add to Cursor" on a marketplace entry to install it and authenticate with OAuth.
                            • [claimed-docs] Configure custom MCP servers with a JSON file
                            • [claimed-docs] Enterprise admins can control which MCP servers users may run from the Cursor dashboard.

                            Slate has a documented Skills system: markdown instruction packages that give the agent domain-specific knowledge/behavior, with example skill definitions and compatibility with Claude Code's `.claude/skills/` format, letting developers equip the agent with custom specialized capabilities. Missing for 10: independent/hands-on verification that custom skills work as documented, and more detail on skill authoring/discovery beyond the single example.

                            • [claimed-docs] Skills are markdown instruction packages that give the agent domain-specific knowledge and behavior.
                            • [claimed-docs] description: "Create distinctive, production-grade frontend interfaces."
                            • [claimed-docs] `.claude/skills/` | Claude Code compatibility
                          2. engineering-leadIntegrate third-party partner-built agent apps into my workflows

                            weight 1 · round to Cursor
                            Cursorfullclaimed7/10

                            Cursor documents a marketplace for adding third-party plugins, skills, and MCP servers with OAuth authentication, plus native integrations with GitHub, GitLab, Slack, Linear, and more, letting teams plug partner-built tools/agents into their workflows, with enterprise admin controls over which servers are allowed. Missing for 10: independent/hands-on corroboration of using specific partner-built agent apps (vs. generic tool connectors) and clearer distinction between simple MCP data-tools and full third-party 'agent apps'.

                            • [claimed-docs] Add plugins, skills, MCPs, and rules from one place
                            • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                            • [claimed-docs] Model Context Protocol (MCP) enables Cursor to connect to external tools and data sources.
                            • [claimed-docs] Click "Add to Cursor" on a marketplace entry to install it and authenticate with OAuth.
                            • [claimed-docs] Configure custom MCP servers with a JSON file
                            • [claimed-docs] Enterprise admins can control which MCP servers users may run from the Cursor dashboard.
                            Slatenone0/10

                            Slate is a coding CLI agent focused on subagents, skills, sessions, and model orchestration; there is no evidence of an ecosystem for integrating third-party partner-built agent apps (e.g., a marketplace, app store, or partner integration framework). Skills compatibility with Claude Code is mentioned but that is file-format compatibility, not partner app integration.

                            • [claimed-docs] Skills are markdown instruction packages that give the agent domain-specific knowledge and behavior.
                            • [claimed-docs] `.claude/skills/` | Claude Code compatibility

                          Team knowledge

                          1. engineering-leadCreate a shared workspace from my docs and repos as a common source of truth for the team

                            weight 1 · round drawn
                            Cursornone0/10

                            Evidence shows integrations (GitHub, Slack, Linear), MCP/plugins, and rules configuration, but nothing describes a dedicated 'shared workspace' feature that unifies docs and repos into a common team source of truth — this is a fair ask for a team-oriented dev tool but unaddressed in the pack.

                              Slatenone0/10

                              Slate is a CLI coding agent focused on individual sessions, workspaces (local directories), skills, and orchestration of subagents—there is no evidence of a shared team workspace or collaborative source-of-truth feature built from docs and repos. The 'workspace' concept here refers to local directory management (/workspace), not a shared team hub.

                              • [claimed-docs] Use `/workspace` to open the workspace manager, where you can review and remove workspace directories.
                              • [claimed-docs] Slate by default respects agent rules in the following order
                              • [claimed-docs] Skills are markdown instruction packages that give the agent domain-specific knowledge and behavior.

                            Tool integration

                            1. developerConnect the agent to workflow tools like Jira, Slack, and Google Drive to extend its context

                              weight 3 · round to Cursor
                              Cursorfullclaimed8/10

                              Cursor documents MCP support that connects to external tools/data sources, an MCP marketplace with OAuth install, and explicit integration with Slack alongside GitHub/GitLab/Linear/Jira-style trackers, plus Slack-based agent collaboration—covering the story's workflow-tool extension use case. Missing for 10: explicit first-party Jira/Google Drive connector documentation and independent hands-on verification of these integrations working end-to-end.

                              • [claimed-docs] Model Context Protocol (MCP) enables Cursor to connect to external tools and data sources.
                              • [claimed-docs] Click "Add to Cursor" on a marketplace entry to install it and authenticate with OAuth.
                              • [claimed-docs] Configure custom MCP servers with a JSON file
                              • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                              • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                              Slatenone0/10

                              No evidence anywhere in the docs pack mentions integrations with Jira, Slack, Google Drive, or any workflow tools/MCP connectors; the docs focus on CLI usage, sessions, skills, and permissions with no mention of external tool connectivity.

                              • developerKick off agent tasks directly from GitHub, GitLab, Linear, or Slack

                                weight 2 · round to Cursor
                                Cursorpartialclaimed7/10

                                Cursor's docs explicitly list integrations with GitHub, GitLab, Slack, and Linear, and describe agents that run on triggers/schedules and collaborate in Slack or review PRs in GitHub, supporting the story's core claim. However, there's no detailed first-party documentation of the exact trigger mechanics per platform (e.g., a Linear ticket auto-spawning an agent) nor independent/hands-on confirmation that this works reliably. Missing for 10: platform-specific trigger documentation for each of GitHub/GitLab/Linear/Slack, and independent verification of the workflow in practice.

                                • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                                • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                                • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                Slatenone0/10

                                No evidence of any integration with GitHub, GitLab, Linear, or Slack for triggering agent tasks; Slate's documentation covers CLI usage, sessions, skills, and configuration but nothing about ecosystem/platform triggers.

                                Ide terminal integration — meeting you in the IDE and terminal — extensions, inline flows, contextIde terminal integration

                                Meeting you in the IDE and terminal — extensions, inline flows, context

                                Cross device continuity

                                1. developerStart a task on one device and continue it later from another device or browser

                                  weight 2 · round to Cursor
                                  Cursorpartialclaimed5/10

                                  Cursor's Background Agents run remotely and can be monitored/interacted with via terminal, Slack, and GitHub PRs, implying a task could be checked or continued from different surfaces, but there is no explicit documentation of resuming a specific in-progress task from a different device or browser session. Missing for 10: explicit cross-device/browser session handoff documentation, hands-on confirmation of resuming a task started elsewhere, and details on state syncing across clients.

                                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                                  • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                                  Slatenone0/10

                                  Docs show session management within Slate (e.g. `/sessions` to switch sessions, `Ctrl+X N` for new session) but only describe local session switching, not any cloud sync or cross-device/browser continuation mechanism. Slate appears to be a terminal-only CLI tool with no mention of a browser interface or account-based sync for resuming tasks elsewhere.

                                Ide integration

                                1. developerChat with the coding assistant directly inside my IDE for contextual help

                                  weight 3 · round to Cursor

                                  Cursor's docs describe an IDE-integrated assistant that traces repo structure, scopes changes via Plan Mode, reproduces issues, and hands off tasks while the developer reviews — all consistent with in-IDE contextual chat, and community commentary confirms it functions as a VS Code-based assistant with prompts/harness. missing for 10: no explicit citation naming a dedicated 'chat panel' UI or independent praise of chat quality/context-awareness specifically.

                                  • [claimed-docs] Trace how a repo fits together and find the right places to start
                                  • [claimed-docs] Scope changes, use Plan Mode, and ship bigger work with confidence
                                  • [claimed-docs] Reproduce issues, narrow the root cause, and verify the fix
                                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                                  • [community] "Cursor is an extension for VS Code, a harness and a bunch of prompts. They have their own model (Composer 2) which is based on Kimi K2.5, b…

                                  Slate is documented as a terminal-based coding agent with session management, `@filename` references, shell execution, and workspace context — providing contextual chat help that developers can run alongside their editor in a terminal. However, there is no evidence of a native IDE extension/panel (e.g., VS Code/JetBrains plugin) that embeds Slate directly inside the IDE UI itself. missing for 10: dedicated IDE extension/panel integration, evidence of in-editor chat UI beyond terminal, independent corroboration of IDE workflow usage.

                                Session management

                                1. developerReview diffs visually and run multiple sessions side by side in a desktop app

                                  weight 2 · round to Cursor
                                  Cursorfullclaimed6/10

                                  Cursor's docs explicitly describe inspecting diffs before merge and launching fleets of agents to work in parallel, both core to a desktop IDE experience with visual diff review and concurrent sessions. Missing for 10: independent/hands-on confirmation of the side-by-side session UI and a detailed walkthrough of the diff viewer beyond marketing copy.

                                  • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                                  Slatenone0/10

                                  Slate is documented as a terminal/CLI tool (npm install, terminal-background onboarding, hotkeys, `/sessions` switching, subagent grid) with no mention of a desktop GUI or visual diff review; session switching is terminal-based, not side-by-side desktop windows. Missing for 10: any evidence of a desktop application, a visual diff viewer, or GUI-based side-by-side session comparison.

                                  • [claimed-docs] npm i -g @randomlabs/slate
                                  • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                  • [claimed-docs] Use `/sessions` to switch between existing sessions
                                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                                  • [claimed-docs] Ctrl+X then N New session
                                2. engineering-leadManage multiple agent-driven coding sessions from one unified workspace

                                  weight 2 · round to Slate
                                  Cursorfullclaimed7/10

                                  Cursor's docs explicitly describe launching 'fleets of agents that work in parallel on ambitious tasks for hours or days' and setting up always-on agents on schedules/triggers, all accessible from Cursor's interface spanning terminal, Slack, and GitHub — directly matching a unified multi-session agent workspace for a lead overseeing parallel work. Missing for 10: independent/hands-on corroboration of the multi-agent dashboard UX, and no detail on cross-session visibility/coordination features specifically framed for engineering-lead oversight.

                                  • [claimed-docs] Launch fleets of agents that work in parallel on ambitious tasks for hours or days.
                                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                                  • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                  • [claimed-docs] Accelerate development by handing off tasks to Cursor, while you focus on making decisions.
                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                                  Docs describe first-class multi-session/multi-agent workspace features: `/sessions` to switch sessions, `/workspace` manager, new-session hotkey, and orchestration showing a grid of inline subagent cards while continuing to chat, queue tasks, or spin up more parallel agents — directly matching the engineering-lead's need to manage multiple concurrent agent sessions from one place. Missing for 10: independent/hands-on verification of this workspace at scale and any lead-specific team-management features beyond individual session switching.

                                  • [claimed-docs] Use `/sessions` to switch between existing sessions
                                  • [claimed-docs] Use `/workspace` to open the workspace manager, where you can review and remove workspace directories.
                                  • [claimed-docs] Those agents show up as a grid of inline subagent cards, one per agent.
                                  • [claimed-docs] While one or more agents run in the background, you can keep talking with Slate: plan next steps, queue up additional tasks, or spin up more…
                                  • [claimed-docs] Ctrl+X then N New session

                                Terminal workflow

                                1. developerRun a coding agent locally from my terminal

                                  weight 3 · round to Slate
                                  Cursorfullprobed7/10

                                  Cursor ships an official CLI (cursor.com/cli) with a documented install command (curl ... | bash) and docs explicitly state 'Cursor runs in your terminal', confirming a local terminal-based agent capability alongside its IDE. Missing for 10: independent/hands-on verification of terminal agent usage and deeper CLI usage documentation beyond the install step.

                                  • [probe] official CLI documented at https://cursor.com/cli
                                  • [claimed-docs] curl https://cursor.com/install -fsS | bash
                                  • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                  Slatefullprobed8/10

                                  Slate ships as a global npm CLI (`npm i -g @randomlabs/slate`) that runs interactively in the terminal, with documented terminal-native features like hotkeys, shell command execution (`!`), file references (`@filename`), session management (`/sessions`), and configuration via `slate.json` — all consistent with a locally-run terminal coding agent. Missing for 10: independent hands-on confirmation of local terminal usage (community evidence only discusses porting-quality skepticism, not terminal operation itself) and no evidence of offline/non-terminal fallback limitations.

                                  • [claimed-docs] npm i -g @randomlabs/slate
                                  • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                  • [claimed-docs] Use `/sessions` to switch between existing sessions
                                  • [claimed-docs] Press Tab to queue the current message so it runs after the current turn finishes.
                                  • [claimed-docs] Execute shell commands directly with `!`
                                  • [claimed-docs] Use `@filename` references
                                  • [claimed-docs] Ctrl+X then N New session
                                  • [probe] official CLI documented at https://docs.randomlabs.ai/en/getting-started/quickstart
                                2. developerRun the agent non-interactively in scripts for workflow automation

                                  weight 2 · round to Cursor
                                  Cursorpartialprobed6/10

                                  Cursor ships an official CLI (cursor-probe-1, cursor-docs-14) and documents 'always-on agents that run on schedules or triggers to build, maintain, and fix your software' (cursor-docs-9), which implies non-interactive/automated agent execution suitable for scripts/CI. However, there is no concrete documentation of CLI flags, headless/print modes, exit codes, or scripting examples, nor independent hands-on confirmation of this workflow. Missing for 10: explicit CLI non-interactive flag/usage docs, examples of piping/scripting the agent, and independent verification that scheduled/triggered agents work as scripted automation.

                                  • [probe] official CLI documented at https://cursor.com/cli
                                  • [claimed-docs] curl https://cursor.com/install -fsS | bash
                                  • [claimed-docs] Set up always-on agents that run on schedules or triggers to build, maintain, and fix your software.
                                  Slatenone0/10

                                  The evidence shows Slate is a CLI-based interactive agent (npm install, onboarding, in-session commands like /sessions, !, @filename) but nowhere documents a non-interactive/headless mode, flags for scripted execution, or CI/automation usage; --dangerously-skip-permissions bypasses prompts but is not shown as enabling scripted/non-interactive invocation. Missing for 10: documentation of a non-interactive/print/exec mode, exit-code or piping behavior, or any CI/scripting examples.

                                  • [claimed-docs] npm i -g @randomlabs/slate
                                  • [claimed-docs] We support `--dangerously-skip-permissions` (alias: `--yolo`) to bypass permission prompts.
                                  • [probe] official CLI documented at https://docs.randomlabs.ai/en/getting-started/quickstart

                                Openness — open source, data portability, and self-hosting storiesOpenness

                                Open source, data portability, and self-hosting stories

                                1. ai-native userDo everything through the API that I can do in the UI

                                  weight 2 · round drawn
                                  Cursornone0/10

                                  The evidence pack shows no public API for Cursor; it mentions an official CLI and MCP (for connecting external tools INTO Cursor), but nothing about a programmatic interface exposing Cursor's own UI capabilities (agents, plan mode, review, etc.) for external control.

                                    Slatenone0/10

                                    No evidence of any public API for Slate — the openapi.json/swagger.json probes returned 404s and no docs reference programmatic endpoints; Slate is documented purely as a CLI/terminal agent with slash-commands, hotkeys, and config files, not an API-driven product with UI/API parity.

                                    • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
                                    • [probe] official CLI documented at https://docs.randomlabs.ai/en/getting-started/quickstart
                                    • [claimed-docs] npm i -g @randomlabs/slate
                                  • ai-native userExport all of my data in open formats and leave

                                    weight 3 · round drawn
                                    Cursornone0/10

                                    No evidence in the pack addresses data export, portability, or open-format data extraction from Cursor; being built on VS Code (a fork) doesn't itself guarantee user data/settings export tooling is documented anywhere here.

                                      Slatenone0/10

                                      No evidence in the docs or elsewhere describes any data export functionality, open-format export, or data portability mechanism for Slate. Sessions, workspace history, and configurations appear stored locally but no documented export/leave path is mentioned. Missing for 10: any documentation of export commands, data format specifications, or account/data portability guarantees.

                                      • ai-native userRead the product's source under an open license

                                        weight 2 · round drawn
                                        Cursornone0/10

                                        Cursor is known to be closed-source (a proprietary VS Code fork), and the evidence pack contains no mention of any open-source license or public repository for Cursor's source code; all references are to product docs, features, or community complaints unrelated to licensing.

                                          Slatenone0/10

                                          No evidence of an open-source license or public source repository for Slate; the CLI is distributed via npm install with no mention of source availability. missing for 10: open-source license declaration, public source repo link, license file/OSS registry evidence.

                                          Pricing limits — free-tier ceilings, usage caps, and rate limits before you have to payPricing limits

                                          Free-tier ceilings, usage caps, and rate limits before you have to pay

                                          Authentication

                                          1. developerAuthenticate with an API key instead of an account login

                                            weight 2 · round drawn
                                            Cursornone0/10

                                            No evidence in the pack describes API key authentication as an alternative to account login for Cursor; docs reference OAuth-based MCP authentication and account-based login flows only.

                                              Slatenone0/10

                                              No evidence pack mentions API key authentication as an alternative to account login; onboarding docs only describe choosing a model source (ChatGPT/Codex, SuperGrok, or Slate credits subscription), not API-key auth. No mention of an API key mechanism anywhere, and the openapi probe returned 404s, giving no indication of an API-key based auth path.

                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                              • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
                                            • engineering-leadAuthenticate through an enterprise identity or cloud platform for compliance and scalability

                                              weight 2 · round drawn
                                              Cursornone0/10

                                              The evidence pack shows Cursor has enterprise admin controls for MCP servers but contains no evidence of SSO/SAML integration, enterprise identity provider authentication (e.g., Okta, Azure AD, Google Workspace), or cloud platform login for compliance purposes. This is a fair and applicable axis for a widely-adopted dev tool sold to enterprises, so absence of evidence yields 'none' rather than 'na'.

                                              • [claimed-docs] Enterprise admins can control which MCP servers users may run from the Cursor dashboard.
                                              Slatenone0/10

                                              No evidence of SSO/SAML/OIDC enterprise identity integration or cloud-platform authentication for compliance; onboarding only mentions choosing a model source (ChatGPT/Codex, SuperGrok, or Slate credits), not enterprise identity federation.

                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                            • developerSign in with my existing product subscription plan to use the coding agent

                                              weight 2 · round to Slate
                                              Cursornone0/10

                                              The evidence pack describes Cursor's agent features, MCP integrations, and installation steps, but contains no documentation or confirmation that users authenticate with an existing subscription plan to access the coding agent (only tangential community chatter about login policy hallucinations). Missing for 10: explicit account/subscription sign-in flow docs, plan-tier access confirmation, and any first-party statement linking subscription plan to agent usage.

                                              • [community] Cursor's AI support agent hallucinated a single-device login policy, telling a user this was intentional. A Cursor developer later clarified…

                                              Docs explicitly state onboarding lets you choose your model source as your existing ChatGPT/Codex subscription or SuperGrok subscription (in addition to Slate credits), directly matching the story of signing in with an existing subscription plan to use the agent. Missing for 10: independent/hands-on confirmation that subscription sign-in actually works end-to-end and any detail on limitations of that mode vs credits.

                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                            • developerSign in with a personal account to get free-tier access without managing API keys

                                              weight 1 · round to Slate
                                              Cursornone0/10

                                              The evidence pack contains no documentation or first-party description of a sign-in flow that grants free-tier access without requiring API keys; only tangential community mentions of account workarounds for usage limits exist. Missing for 10: any docs on account creation/sign-in, free-tier terms, or explicit no-API-key requirement.

                                              • [community] Cursor is caught in a cat-and-mouse game against workarounds where users create new accounts to get unlimited use; a repo enabling this (cur…

                                              Docs show onboarding lets users choose a model source including an existing ChatGPT/Codex or SuperGrok subscription instead of managing API keys, implying account-based auth is supported, but there's no explicit mention of a free tier or of signing in with a personal Slate account for free credits without a paid subscription. Missing for 10: explicit free-tier account sign-in flow, confirmation that 'Slate credits' option requires no payment, and any account-based (not subscription-based) login mechanism.

                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…

                                            Model choice

                                            1. developerLet the tool automatically pick the best model for each task

                                              weight 1 · round to Slate
                                              Cursornone0/10

                                              The evidence shows Cursor lets developers manually choose among multiple models (OpenAI, Anthropic, Gemini, etc.) but nothing indicates an automatic 'best model for the task' selection feature. missing for 10: any documentation or claim of an auto-select/router feature that picks models per task, evidence of cost/performance-based automatic routing.

                                              • [claimed-docs] Choose between every cutting-edge model from OpenAI, Anthropic, Gemini, SpaceXAI, and Cursor.

                                              Docs explicitly claim Slate 'automatically selects the right model for the job' and also allow developers to set preferred default models per slot via `/models` or `slate.json`, suggesting a hybrid automatic+manual approach relevant to pricing/limits tradeoffs. However, there's no detail on the selection logic, cost-awareness, or independent verification that auto-selection actually optimizes for task/price. Missing for 10: independent hands-on confirmation of auto-selection quality, explanation of selection criteria (cost vs capability), and evidence of pricing-limit awareness in model choice.

                                              • [claimed-docs] Slate automatically selects the right model for the job.
                                              • [claimed-docs] Set preferred default models for each slot with the `/models` dialog or `slate.json` under `models`.
                                            2. developerChoose which underlying AI model powers my session from multiple providers

                                              weight 2 · round to Cursor
                                              Cursorfullclaimed8/10

                                              cursor-docs-7 confirms Cursor lets developers choose between models from multiple providers (OpenAI, Anthropic, Gemini, and Cursor's own), directly matching the story. Missing for 10: independent hands-on verification of per-session model switching UI/behavior and pricing implications tied to model choice.

                                              • [claimed-docs] Choose between every cutting-edge model from OpenAI, Anthropic, Gemini, SpaceXAI, and Cursor.

                                              Docs confirm model source can be chosen at onboarding (ChatGPT/Codex, SuperGrok, or Slate credits) and that default models per 'slot' can be set via `/models` or slate.json, showing multi-provider flexibility. However, this is framed around subscription/credit sources rather than a clear list of many independent model providers, and there's no independent/hands-on verification of switching providers mid-session. missing for 10: independent corroboration of provider switching, a full list of supported model providers, and confirmation this works reliably in practice.

                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                              • [claimed-docs] Set preferred default models for each slot with the `/models` dialog or `slate.json` under `models`.

                                            Privacy posture — data-handling and privacy storiesPrivacy posture

                                            Data-handling and privacy stories

                                            1. ai-native userChoose where my data is stored (region/residency)

                                              weight 2 · round drawn
                                              Cursornone0/10

                                              No evidence in the pack mentions data residency, region selection, or storage location controls for Cursor; the docs snippets cover agents, MCP, and integrations but nothing about choosing data storage region. Missing for 10: any mention of regional data residency options, enterprise data location controls, or compliance documentation addressing storage jurisdiction.

                                                Slatenone0/10

                                                Slate is a CLI coding agent tool; the evidence pack contains no mention of data residency, region selection, or storage location controls. Missing for 10: any documentation of data residency options, regional storage configuration, or compliance controls.

                                                • ai-native userPrevent my data from being used to train AI models

                                                  weight 3 · round drawn
                                                  Cursornone0/10

                                                  The evidence pack contains no documentation of a privacy mode, opt-out of training, or data-retention controls for Cursor; all cited docs cover unrelated features (agents, MCP, integrations) and community threads are unrelated to training-data privacy.

                                                    Slatenone0/10

                                                    No evidence in the pack addresses data-training opt-out, privacy policy, or any control over model training use; the documentation covers CLI usage, orchestration, and skills but nothing about data privacy posture. Missing for 10: any privacy policy statement, opt-out settings, or data usage terms regarding AI training.

                                                    • ai-native userControl data retention and deletion

                                                      weight 2 · round drawn
                                                      Cursornone0/10

                                                      The evidence pack contains no documentation of data retention settings, deletion controls, privacy dashboard, or data handling policies for Cursor; only unrelated docs on features (MCP, agents, integrations) and community complaints about bugs/pricing are present. Missing for 10: any first-party privacy policy docs, retention period settings, data deletion request mechanism, or enterprise data controls.

                                                        Slatenone0/10

                                                        No evidence pack items mention data retention policies, deletion controls, or privacy settings for user data/sessions; docs cover workspace management and permissions but not data retention/deletion. Missing for 10: any documentation of data retention periods, deletion mechanisms, or export/erase controls.

                                                        • ai-native userOpt out of telemetry and usage tracking

                                                          weight 2 · round drawn
                                                          Cursornone0/10

                                                          The evidence pack contains no mention of telemetry settings, privacy controls, or usage-tracking opt-out mechanisms; docs only cover unrelated features like MCP, agents, and integrations. Missing for 10: any privacy policy or settings documentation, telemetry opt-out toggle, or usage data collection disclosure.

                                                            Slatenone0/10

                                                            No evidence pack item mentions telemetry, usage tracking, analytics, or an opt-out setting anywhere in Slate's docs or community coverage; the closest item (diagnostic attachment on bug reports) doesn't address general telemetry opt-out. Missing for 10: any mention of telemetry collection, a privacy policy, or a documented opt-out flag/setting.

                                                            • [claimed-docs] Slate automatically attaches relevant diagnostic information (OS, version, session context) to your report.

                                                          Review safety — keeping generated changes safe — diffs, approvals, guardrailsReview safety

                                                          Keeping generated changes safe — diffs, approvals, guardrails

                                                          Data governance

                                                          1. engineering-leadOpt out of having my code and prompts used for AI model training

                                                            weight 1 · round drawn
                                                            Cursornone0/10

                                                            The evidence pack contains no mention of privacy settings, opt-out of training, or data usage policies for Cursor; all docs entries relate to unrelated features (agents, MCP, integrations) and community items focus on bugs/pricing/model sourcing, not training data controls.

                                                              Slatenone0/10

                                                              No evidence in the pack addresses data usage, training opt-out, or privacy policy for prompts/code submitted to Slate or its model providers.

                                                              Pr review

                                                              1. developerHave the agent stage changes, write commit messages, create branches, and open pull requests

                                                                weight 3 · round to Cursor
                                                                Cursorpartialclaimed4/10

                                                                Docs show GitHub/GitLab integration and agents that build/test/demo work end-to-end for review (cursor-docs-6, cursor-docs-10, cursor-docs-12), implying some git-workflow automation, but there's no explicit documentation of the agent staging changes, writing commit messages, creating branches, or opening pull requests. missing for 10: explicit commit-message generation, branch creation, PR-opening workflow documentation, and any hands-on confirmation these steps work end-to-end.

                                                                • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                                                                • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                                                • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                                                                • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                                                                Slatenone0/10

                                                                No evidence in the pack mentions git operations like staging, committing, branching, or opening pull requests; documentation covers sessions, orchestration, skills, permissions, and CLI setup but not any git/PR workflow. Absence of evidence for this applicable capability means the verdict is none.

                                                                • developerInspect diffs and run checks to catch problems before merging

                                                                  weight 3 · round to Cursor
                                                                  Cursorpartialclaimed5/10

                                                                  cursor-docs-4 explicitly claims the capability ('Inspect diffs, run checks, and catch problems before you merge') and cursor-docs-10/12 support a broader PR review workflow, but there is no independent or hands-on corroboration of diff inspection or check-running in practice, and community evidence focuses on unrelated bugs/pricing rather than this feature. missing for 10: independent verification of diff review UI, details on what 'checks' run (tests/linters/CI), and hands-on confirmation of pre-merge workflow.

                                                                  • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                                                                  • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.

                                                                  Slate's docs mention it can perform integration tests manually (random-labs-docs-16), implying some check-running capability, but there is no evidence of diff inspection, git diff review, PR-style change summaries, or pre-merge validation workflows. missing for 10: diff/change inspection UI or command, explicit pre-merge check/test running workflow, and any corroborating hands-on evidence of catching problems before merge.

                                                                  • [claimed-docs] Slate is one of the few agents capable of performing integration tests manually.

                                                                Safe execution

                                                                1. engineering-leadControl which external tools and integrations the agent is allowed to access

                                                                  weight 2 · round to Cursor
                                                                  Cursorfullclaimed8/10

                                                                  Docs show enterprise admins can restrict which MCP servers users may run from the Cursor dashboard, and users can toggle individual servers on/off, giving engineering leads direct control over external tool/integration access. Missing for 10: independent/hands-on corroboration of the admin dashboard controls and finer-grained per-tool permission examples beyond MCP servers.

                                                                  • [claimed-docs] Enterprise admins can control which MCP servers users may run from the Cursor dashboard.
                                                                  • [claimed-docs] Toggle servers on/off without removing them
                                                                  • [claimed-docs] Model Context Protocol (MCP) enables Cursor to connect to external tools and data sources.
                                                                  • [claimed-docs] Configure custom MCP servers with a JSON file

                                                                  Slate's configuration docs describe a permission system where each permission key maps to allow/ask/deny actions or fine-grained pattern objects, which supports controlling what tools/actions the agent can perform, and a `--yolo` flag exists to bypass these prompts entirely. However there's no explicit documentation of controlling specific external integrations (e.g., MCP servers, API connectors) or org/team-level lockdown for an engineering lead specifically. Missing for 10: explicit external-integration/MCP allowlist docs, engineering-lead/team-level enforcement (vs individual config), and independent verification that permission enforcement can't be trivially bypassed.

                                                                  • [claimed-docs] Each permission key maps to an action ("allow", "ask", or "deny"), or a pattern object for fine-grained control.
                                                                  • [claimed-docs] We support `--dangerously-skip-permissions` (alias: `--yolo`) to bypass permission prompts.
                                                                2. engineering-leadHave the agent operate inside a sandbox when interacting with code, tools, and network resources

                                                                  weight 2 · round drawn
                                                                  Cursornone0/10

                                                                  The evidence pack contains no mention of sandboxing, isolated execution environments, or network/tool restriction controls for the agent; docs describe agents using 'their own computers' but give no detail on containment/sandboxing mechanisms. Missing for 10: any documentation of a sandbox/isolation feature, network egress controls, or filesystem restriction for agent actions.

                                                                  • [claimed-docs] Agents use their own computers to build, test, and demo features end to end for you to review.
                                                                  Slatenone0/10

                                                                  The evidence shows a permission system (allow/ask/deny actions) and a --yolo flag to bypass prompts, but there is no mention of sandboxed execution, containerization, or network isolation for the agent's code/tool interactions. missing for 10: any documentation of sandbox/container execution, network isolation controls, or filesystem confinement mechanisms.

                                                                  • [claimed-docs] Each permission key maps to an action ("allow", "ask", or "deny"), or a pattern object for fine-grained control.
                                                                  • [claimed-docs] We support `--dangerously-skip-permissions` (alias: `--yolo`) to bypass permission prompts.

                                                                Security checks

                                                                1. engineering-leadSee license and public-code matching references for AI-suggested code

                                                                  weight 1 · round drawn
                                                                  Cursornone0/10

                                                                  No evidence anywhere in the pack mentions license detection, public code matching, provenance references, or IP attribution for AI-suggested code; docs focus on repo navigation, diffs, agents, and integrations, none of which addresses license/code-match transparency.

                                                                    Slatenone0/10

                                                                    No evidence anywhere in the pack mentions license compliance checks, public-code/OSS matching, or provenance references for AI-suggested code; the docs cover orchestration, skills, permissions, and CLI usage but nothing about code provenance/license scanning.

                                                                    • developerGet contextual explanations and automatic fixes for security vulnerabilities

                                                                      weight 2 · round drawn
                                                                      Cursornone0/10

                                                                      The evidence pack shows general code review/diff-inspection features (cursor-docs-4) and broad agent capabilities, but nothing specifically documents contextual security vulnerability explanations or automated security fixes. Missing for 10: any mention of vulnerability detection, security scanning integration, or CVE/security-specific fix suggestions.

                                                                        Slatenone0/10

                                                                        No evidence in the pack mentions security vulnerability detection, explanations, or automatic fixes; documentation covers session management, orchestration, skills, and configuration but nothing about security review or vulnerability remediation. Missing for 10: any mention of vulnerability scanning, security explanations, or auto-fix capability.

                                                                        Not comparable on these axes

                                                                        1. ai-native userConnect an agent via an official MCP server

                                                                          weight 3 · not comparable
                                                                          Cursorn/a

                                                                          Cursor is itself an AI coding agent; the evidence (cursor-docs-15 to cursor-docs-19) shows Cursor acting as an MCP client that connects to external MCP servers, not Cursor exposing an official MCP server for other agents to connect to. Per the agent-role exception, client-side MCP support does not make this server-side story applicable.

                                                                            Slaten/a

                                                                            Slate is itself a coding agent (CLI-based, with sessions, subagents, skills); serving as an MCP server for other agents to connect to is a different product role. No evidence shows Slate exposing an official MCP server endpoint, so the axis does not apply per the agent-role exception.

                                                                            • ai-native userSubscribe to events via webhooks

                                                                              weight 2 · not comparable
                                                                              Cursornone0/10

                                                                              Evidence covers MCP integration, background agents, and IDE integrations, but there is no mention of a webhook subscription mechanism for external event notifications.

                                                                                Slaten/a

                                                                                Slate is a CLI-based coding agent, not a service/platform exposing an event system; webhook subscriptions are outside its product category, and no evidence pack item references webhooks or event subscriptions at all.

                                                                                • ai-native userExplore an interactive API reference with runnable examples

                                                                                  weight 2 · not comparable
                                                                                  Cursornone0/10

                                                                                  No evidence of an interactive API reference with runnable examples for Cursor; docs entries describe product features and MCP setup but nothing about an API reference or executable code samples.

                                                                                    Slaten/a

                                                                                    Slate is a CLI coding agent, not an API/service product with its own API reference; the probe explicitly found no OpenAPI spec, confirming this axis is a category mismatch rather than a missing feature.

                                                                                    • [probe] PROBE openapi: all candidate paths 404 (https://docs.randomlabs.ai/openapi.json, https://docs.randomlabs.ai/swagger.json, https://docs.rando…
                                                                                  • ai-native userTest against a sandbox environment without touching production data

                                                                                    weight 1 · not comparable
                                                                                    Cursorn/a

                                                                                    Sandbox testing environments vs production data isolation is a data/infrastructure axis relevant to backend/platform products, not to an AI coding assistant like Cursor, which operates on local/repo code rather than managing production data environments.

                                                                                      Slaten/a

                                                                                      Slate is a coding agent CLI tool, not a service with a sandbox/production data separation model; there's no evidence of a hosted environment with production data that would need a sandbox testing mode. This axis is a category error for this kind of local developer tool.

                                                                                      • developerReceive inline code completions and next-edit suggestions as I type

                                                                                        weight 3 · not comparable
                                                                                        Cursornone0/10

                                                                                        The evidence pack contains no first-party documentation or hands-on account describing Cursor's own inline code completion or next-edit suggestion feature; only tangential community references compare competitors' tab-completion tools (e.g., Continue, SuperMaven) without confirming or detailing Cursor's implementation. Missing for 10: any first-party doc on Cursor's Tab/inline completion feature, hands-on confirmation it works as typed, and mention of 'next-edit' suggestion behavior.

                                                                                          Slaten/a

                                                                                          Slate is a terminal/CLI-based agentic coding assistant that operates via chat sessions, orchestration, and shell commands, not an IDE-integrated editor extension providing inline completions or next-edit suggestions as the user types. This story targets an IDE-autocomplete category error for Slate's product type.

                                                                                          • developerView interactive diffs and share selected code as context from within my JetBrains IDE

                                                                                            weight 1 · not comparable
                                                                                            Cursornone0/10

                                                                                            The only evidence touching JetBrains is a single line listing JetBrains among integrations (cursor-docs-6), with no detail on interactive diffs or context-sharing features within a JetBrains IDE specifically. No documentation, screenshots, or community reports confirm this JetBrains-specific capability.

                                                                                            • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                                                                                            Slaten/a

                                                                                            Slate is a terminal/CLI-based coding agent (npm-installed CLI, terminal UI, hotkeys), with no evidence of a JetBrains IDE plugin, interactive diff viewer inside an IDE, or IDE-based context sharing. This story targets IDE-native integration, which is a different product surface than Slate's terminal-first design.

                                                                                          • ai-native userSelf-host the core product

                                                                                            weight 3 · not comparable
                                                                                            Cursorn/a

                                                                                            Cursor is a proprietary AI coding assistant/IDE fork product, not an open-source or self-hostable platform; self-hosting the core product is a category error for this type of closed commercial tool.

                                                                                              Slatenone0/10

                                                                                              No evidence anywhere in the docs of Slate being open-source or offering a self-hosted deployment option; it's installed via npm as a CLI that connects to model subscriptions/credits, implying a hosted/service model rather than self-hostable core infrastructure. Missing for 10: any mention of self-hosting instructions, open-source repo, or on-prem deployment option.

                                                                                              • [claimed-docs] npm i -g @randomlabs/slate
                                                                                              • [claimed-docs] Onboarding asks for your terminal background, multiline input preference, and model source: your ChatGPT/Codex subscription, SuperGrok subsc…
                                                                                            • developerGet automatic code review with contextual feedback on every pull request

                                                                                              weight 3 · not comparable
                                                                                              Cursorfullclaimed7/10

                                                                                              Cursor's docs explicitly claim it 'reviews PRs in GitHub' and can 'inspect diffs, run checks, and catch problems before you merge,' directly matching automated PR review with contextual feedback, backed by GitHub/GitLab/Bitbucket integration claims. missing for 10: independent/hands-on verification of review quality, details on triggering on every PR automatically, and no community corroboration of this specific feature.

                                                                                              • [claimed-docs] Cursor runs in your terminal, collaborates in Slack, and reviews PRs in GitHub.
                                                                                              • [claimed-docs] Inspect diffs, run checks, and catch problems before you merge
                                                                                              • [claimed-docs] Work with GitHub, GitLab, Azure DevOps, Bitbucket, JetBrains, Slack, Linear, and more
                                                                                              Slaten/a

                                                                                              Slate is a terminal-based coding agent CLI (session management, orchestration, skills, permissions) with no evidence of PR/VCS integration or automated code review on pull requests. Automatic PR review is a GitHub/CI-integration feature category, not something this agentic CLI tool is positioned to do — no docs mention PR hooks, CI integration, or review workflows tied to pull requests, making this a category mismatch rather than a gap in an applicable feature.