Skills, subagents and hooks that help coding agents write, run and fix Robot Framework tests. They work with eight agents: Claude Code, GitHub Copilot CLI, GitHub Copilot in VS Code, OpenAI Codex, Cursor, OpenCode, Project Goose and Claude Desktop.

Install rf-core for the Robot Framework language, environment setup and Python keyword libraries, then add the plugin for each library you test with: web, API, mobile or desktop. The plugins sit next to the RobotCode project's own robotcode plugin, which teaches agents the robotcode CLI.

Requires the robotcode CLI (robotcode[all]>=2.8) in the project's Python environment. See Prerequisites.

Tiers and what they mean: GOVERNANCE.md. Full details per plugin: docs/catalog.md.

The Python installer bundles these plugin versions:

There are two ways to install, and both work at user scope (every project on your machine) or project scope (one repository, shared with your team):

• Plugin marketplace: Claude Code, GitHub Copilot CLI, VS Code (Copilot), OpenAI Codex and Cursor all read this repository's .claude-plugin/marketplace.json. Add the marketplace MarketSquare/robotframework-plugins and install rf-core plus the technology plugins you need, or the rf-agentskills bundle. Updates arrive through the agent.
• Python installer (robotframework-plugins): copies the files into each agent's own folders. Use it for OpenCode, Goose and Claude Desktop, which have no plugin marketplace, or wherever you prefer plain files. It can also write the marketplace settings for you (--mode plugin).

Install rf-core plus the plugins for the libraries you test with, for example rf-core and rf-web for a Browser project. Claude Code installs rf-core with any technology plugin. Copilot CLI and Codex don't install plugin dependencies, so install rf-core there too. The Python installer picks the plugins from the libraries your pyproject.toml or requirements*.txt declares.

Install either the rf-agentskills bundle or separate plugins, not both, or each skill appears twice. Skill names are the same everywhere; only their prefix differs. With the bundle, skills keep the prefix they had up to 3.0.0 (/rf-agentskills:rf-browser). With separate plugins, each skill carries its plugin's prefix (/rf-web:rf-browser, /rf-core:rf-language), so update project instructions that name a prefixed skill when you switch.

The plugin does not set a default main agent. The three subagents are available for delegation, and you can still choose one as your main agent yourself.

Project scope for your team. Commit this .claude/settings.json (or let robotframework-plugins install --mode plugin merge it into the existing file):

{
  "extraKnownMarketplaces": {
    "robotframework-plugins": {
      "source": { "source": "github", "repo": "MarketSquare/robotframework-plugins" }
    }
  },
  "enabledPlugins": {
    "rf-core@robotframework-plugins": true,
    "rf-web@robotframework-plugins": true
  }
}

Enable rf-agentskills@robotframework-plugins instead to get everything. Add "ref" to the source to pin the marketplace to a tag, or use stable for the latest release. Each plugin release is tagged <plugin>--v<version> (for example rf-core--v1.0.0); the older v<version> tags install rf-agentskills up to 3.0.0.

claude plugin marketplace add MarketSquare/robotframework-plugins
claude plugin install rf-web@robotframework-plugins                  # brings rf-core; --scope user (default) | project | local
# or everything at once: claude plugin install rf-agentskills@robotframework-plugins
# recommended companion: the robotcode plugin
claude plugin marketplace add robotcodedev/robotframework-agent-plugins
claude plugin install robotcode@robotframework-agent-plugins

In a session, /plugin marketplace add … and /plugin install … do the same. --scope project writes the committed .claude/settings.json above. To try the in-tree plugins without a marketplace: claude --plugin-dir ./plugins/rf-core --plugin-dir ./plugins/rf-web.

copilot plugin marketplace add MarketSquare/robotframework-plugins
copilot plugin install rf-core@robotframework-plugins               # Copilot CLI doesn't install dependencies
copilot plugin install rf-web@robotframework-plugins
# or everything at once: copilot plugin install rf-agentskills@robotframework-plugins
# recommended companion: the robotcode plugin
copilot plugin marketplace add robotcodedev/robotframework-agent-plugins
copilot plugin install robotcode@robotframework-agent-plugins

That is user scope. For project scope, commit .claude/settings.json (or .github/copilot/settings.json with the same keys) and list rf-core there too: Copilot CLI loads the plugins in that repository without an install step. Pin a release with its ref there.

Copilot CLI passes only a hook's decision/reason to the model. So the model sees Robot Framework validation errors after an edit ("The edit was applied, but …"), but not the advisory context the other agents get: deprecation and formatting warnings, the skill hint on prompts, error hints after robot runs, and the session environment report.

Plugins and hooks are preview features. In your user settings, enable them and add the marketplace:

{
  "chat.plugins.enabled": true,
  "chat.useHooks": true,
  "chat.plugins.marketplaces": ["MarketSquare/robotframework-plugins"]
}

Pin with "MarketSquare/robotframework-plugins#rf-core--v1.0.0". Then install rf-core and the technology plugins you need (or the rf-agentskills bundle) from that marketplace in the Extensions view. For project scope, the committed .claude/settings.json recommends the plugin to everyone who opens the workspace (chat.plugins.marketplaces itself is a user-only setting). VS Code asks before running hook commands unless your chat approval mode allows them. The RobotCode extension already bundles the robotcode plugin for Copilot Chat, so it needs no separate install.

VS Code 1.142 has two agent harnesses, with different gaps:

• Copilot (agent host): validation errors reach the model, but the plugin's three subagents are not offered.
• Local: skills and subagents work, but VS Code sends the next model request without waiting for PostToolUse hooks. A validation error first appears only as the banner "A hook prevented chat from continuing". The plugin's Stop hook re-checks the file when the agent finishes its reply and hands the error to the model, which then gets another turn to fix it.

codex plugin marketplace add MarketSquare/robotframework-plugins        # pin: --ref rf-core--v1.0.0
codex plugin add rf-core@robotframework-plugins                         # Codex doesn't install dependencies
codex plugin add rf-web@robotframework-plugins
# or everything at once: codex plugin add rf-agentskills@robotframework-plugins
# recommended companion: the robotcode plugin
codex plugin marketplace add robotcodedev/robotframework-agent-plugins
codex plugin add robotcode@robotframework-agent-plugins

Then, once, run /hooks in a Codex session and trust the plugin's hooks; Codex runs none of them before that. Codex plugins cannot ship subagents, so install the three TOML subagents with the installer:

uvx robotframework-plugins install --agent codex --mode plugin            # writes .codex/agents/*.toml, prints the commands
uvx robotframework-plugins install --agent codex --mode plugin --yes      # also runs them

Codex has no committed project-scope plugin file: every user runs the codex plugin commands once. The subagents can be committed in .codex/agents/.

Add the marketplace by its git URL, https://github.com/MarketSquare/robotframework-plugins (Customize → Plugins, or cursor-agent plugin marketplace add …), install rf-core and the technology plugins you need (or rf-agentskills) and choose project or user scope. Cursor keeps marketplaces on your Cursor account. It also imports the plugin when it is installed in Claude Code or enabled in .claude/settings.json (Settings → Third-Party Imports). Add https://github.com/robotcodedev/robotframework-agent-plugins the same way for the robotcode plugin.

Run it with zero install and let it walk you through the agents to set up:

# Zero-install: bare `install` is interactive — multi-select of known agents,
# with the ones detected on your machine pre-checked.
uvx robotframework-plugins install            # or: pipx run robotframework-plugins install

# See what's detected first
uvx robotframework-plugins targets

Fully scriptable too — no prompt with an explicit selection, --yes, or a non-TTY stdin:

robotframework-plugins install --agents all                 # every known agent
robotframework-plugins install --agents claude-code,cursor  # explicit list
robotframework-plugins install --agents detected --yes      # only detected, headless
robotframework-plugins install --agent claude-code          # single (back-compat)
robotframework-plugins install --agent claude-code --mode plugin --ref rf-core--v1.0.0   # marketplace settings instead of files

Installs default to project scope (into the current directory, e.g. ./.claude/); add --scope user for a global install under your home directory. Other commands: uninstall, list, doctor, version. Useful flags: --scope project|user [--project DIR], --mode files|plugin [--ref TAG], --prefix DIR, --dry-run, --what skills,agents,hooks, --force, --no-input.

--mode plugin writes the marketplace entries into .claude/settings.json (Claude Code, Copilot, VS Code; Copilot also gets .github/copilot/settings.json, or ~/.copilot/settings.json for user scope), installs the Codex subagents and prints the Codex commands, and prints the Cursor steps. Agents without a marketplace (OpenCode, Goose, Claude Desktop) fall back to files.

A manifest (per-project under <project>/.rf-agentskills/, or global for user scope) tracks every file written (hash + transform); uninstall removes only files whose hash still matches and only the hook config entries it added — user edits and other tools' hooks are preserved. Re-running install after an upgrade removes files the previous install wrote that the new bundle no longer ships (same hash check; user-modified files are kept), including the rf-tools MCP server entry and files that installers before content 2.0.0 registered.

Release notes, sha256 hashes, and the latest wheel + sdist are on the robotframework-plugins releases page (tag prefix robotframework-plugins-v*) and on PyPI.

Each skill is a self-contained folder under plugins/<plugin>/skills/. Copy what you need into the folder your agent reads skills from:

cp -r plugins/rf-web/skills/rf-browser <your-project>/.claude/skills/

Agents read project skills from .claude/skills/ (Claude Code, Copilot), .agents/skills/ (Codex), .cursor/skills/ (Cursor) and similar folders. Each release also attaches a tarball of standalone skill folders, with plain script paths.

Every plugin has a tier, shown in the catalogue above.

• verified: the Foundation reviewers approved it. It has at least two maintainers, trigger tests and eval tasks for every skill, and eval baselines on the current models that it keeps passing.
• community: it passes the same automated checks (house content rules, the security scanners, frontmatter and example checks) and a maintainer review, without the eval evidence.

A tier describes the evidence behind a plugin, not a warranty. The checks and reviews lower the risk of a harmful or broken plugin; they don't prove that one is safe. Plugins give instructions to an agent that can run commands on your machine, so read what you install, as you would any other dependency. GOVERNANCE.md has the full criteria, and SECURITY.md says what the security checks cover.

The installer, hooks and scripts send nothing anywhere. The installer only touches the network for the marketplace and package operations you ask for. To learn which plugins help, the project uses public signals (GitHub traffic, PyPI downloads, issues) and the plugin feedback form.

• Post-save validation: Checks every written .robot/.resource file with robotcode analyze code (project environment first): syntax, argument and import errors are fed back to the agent; unknown keywords and variables are reported, and block only if still unresolved when the agent finishes; Robocop adds advice: deprecated syntax ([Return], Run Keyword If, Force Tags, …) is reported as a non-blocking warning (RF_AGENTSKILLS_DEPRECATION_CHECK=warn|off); an opt-in per-file dry run (RF_AGENTSKILLS_FILE_DRYRUN=1). See plugins/rf-core/hooks/README.md.
• Skill routing: Routes RF-related prompts to the appropriate skill (short routing text, ≤ 450 characters)
• Environment check: Checks for Robot Framework, robotcode (≥ 2.8) and the RF packages at session start (install advice via rf-setup)
• Test reminder: Reminds you to run tests when the session ends

• A supported coding agent (see the install matrix above)

• Python 3.10+ and robotframework in the project environment

• robotcode[all] 2.8 or later in the project environment. The skills run robotcode doc, robotcode analyze code, robotcode results and robotcode robot-debug, and the validation hooks run robotcode analyze code. Install it next to Robot Framework, never with uvx, pipx or uv tool (an isolated robotcode cannot see the project's libraries):

  uv add --dev "robotcode[all]>=2.8"                 # uv
  poetry add --group dev "robotcode[all]>=2.8"       # Poetry
  pip install "robotcode[all]>=2.8"                  # venv + pip (venv active)

  Why [all]: the base package only has config and profiles; the skills need the runner (robot, discover, results), analyze and repl (doc, robot-debug) extras, and the hooks need Robocop, which only [all] brings in as well. A CI job that only runs tests can use robotcode[runner].

• Recommended: the robotcode plugin (robotcode@robotframework-agent-plugins) next to rf-agentskills. It owns running, discovery, keyword documentation, result analysis, static analysis, robot.toml configuration, the REPL and the debugger; rf-agentskills owns Robot Framework syntax, Python keyword libraries, the test-library skills, environment setup, the validation hooks and the design, diagnosis and migration subagents.

• New to Robot Framework setup? The setup skill (rf-setup) walks an agent through installing it into a project environment (uv preferred; it also covers venv + pip and Poetry).

uv add robotframework        # pip alternative (inside the project venv): pip install robotframework

All scripts handle a missing robotframework package gracefully and report how to install it.

Optional libraries (for their respective skills), installed into the project environment -- same commands as the rf-setup skill's library table:

uv add "robotframework-browser[bb]" && uv run rfbrowser install chromium   # Browser skill (no Node.js needed)
uv add robotframework-seleniumlibrary              # Selenium skill (Selenium Manager fetches drivers)
uv add robotframework-appiumlibrary                # Appium skill (+ npm Appium server and drivers)
uv add robotframework-requests                     # Requests skill
uv add RESTinstance                                # RESTinstance skill (Python 3.11+)
uv add --prerelease allow robotframework-PlatynUI  # PlatynUI skill (preview; Python 3.12+; a plain install gets old 0.9.2)

• Robot Framework 7+ (uses modern syntax: RETURN, IF/ELSE, TRY/EXCEPT)
• Python 3.10+ (installer, skill scripts and robotcode)
• robotcode 2.8+ with the all extra, in the project environment
• Coding agents (see the install matrices above): Claude Code ≥ 2.1, GitHub Copilot CLI (plugin verified with 1.0.91), GitHub Copilot in VS Code ≥ 1.108 (plugin verified with 1.138 and 1.142), OpenAI Codex (plugin verified with 0.153.4 and 0.161.0), Cursor ≥ 2.4 (plugin loader checked in CLI 2026.10.01), OpenCode, Project Goose ≥ 1.25, Claude Desktop (skills via ZIP upload)

Up to 3.0.0 everything shipped as one plugin, rf-agentskills, from a personal repository, with the installer on PyPI as rf-agentskills. Both moved here:

• Marketplace: add MarketSquare/robotframework-plugins and install the plugins you need, or the rf-agentskills 4.0.0 bundle to keep everything as it was. Old pins to v3.0.0 keep working from the archived repository.
• Installer: run uvx robotframework-plugins install. It finds files the old installer wrote, moves them to the new layout and keeps the ones you edited. rf-agentskills 0.9.0 on PyPI forwards to it.

The rf-agentskills changelog lists the skills renamed in 2.0 and removed in 3.0.

• CONTRIBUTING.md: add or change a plugin, run the checks and tests, and which version to bump.
• GOVERNANCE.md: tiers, review, maintainer expectations, deprecation and removal.
• SECURITY.md: report a vulnerability privately; what the checks cover and what they can't.
• RELEASING.md: plugin and installer releases.

Apache-2.0