Robot Framework plugins

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.

Catalogue

Plugin	Version	Tier	Status	What it covers	Libraries	Maintainers
`rf-agentskills`	4.0.0	verified	active	All Robot Framework plugins in one install (rf-core, rf-web, rf-api, rf-mobile, rf-desktop), as one plugin.	Robot Framework	@manykarim
`rf-api`	1.0.0	verified	active	RequestsLibrary and RESTinstance skills for API tests.	RequestsLibrary, RESTinstance	@manykarim
`rf-core`	1.0.0	verified	active	Robot Framework syntax, environment setup, Python keyword libraries, test design and debugging subagents, and the validation hooks.	Robot Framework	@manykarim
`rf-desktop`	1.0.0	verified	active	PlatynUI skill for desktop UI tests.	PlatynUI	@manykarim
`rf-mobile`	1.0.0	verified	active	AppiumLibrary skill for Android and iOS tests.	AppiumLibrary	@manykarim
`rf-web`	1.0.0	verified	active	Browser Library and SeleniumLibrary skills for web tests.	Browser, SeleniumLibrary	@manykarim

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

The Python installer bundles these plugin versions:

robotframework-plugins 2026.11.0 bundles	Version	Tier
`rf-agentskills`	4.0.0	verified
`rf-api`	1.0.0	verified
`rf-core`	1.0.0	verified
`rf-desktop`	1.0.0	verified
`rf-mobile`	1.0.0	verified
`rf-web`	1.0.0	verified

Install

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).

Which plugins

Plugin	What it adds
`rf-core`	Robot Framework syntax (`rf-language`), environment setup (`rf-setup`), Python keyword libraries (`rf-python-library`); the `rf-test-architect`, `rf-debug-expert` and `rf-migration-guide` subagents; all hooks. Every other plugin needs it.
`rf-web`	Browser Library (`rf-browser`) and SeleniumLibrary (`rf-selenium`)
`rf-api`	RequestsLibrary (`rf-requests`) and RESTinstance (`rf-restinstance`)
`rf-mobile`	AppiumLibrary (`rf-appium`)
`rf-desktop`	PlatynUI (`rf-platynui`)
`rf-agentskills`	A bundle: a copy of all five, in one install, as before 4.0.0

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.

Plugin marketplace, per agent

Agent (verified version)	Skills	Subagents	Hooks	Project scope (committed file)
Claude Code	yes	yes	yes	`.claude/settings.json` enables the plugin
Copilot CLI (1.0.91)	yes	yes	yes; only validation errors reach the model (see below)	`.claude/settings.json` or `.github/copilot/settings.json` loads the plugin, no install step
VS Code Copilot (1.142)	yes	yes in the Local harness; not offered in the Copilot harness	yes, with `chat.useHooks`; in the Local harness validation errors reach the model only at the end of the reply (see below)	`.claude/settings.json` recommends the plugin to the workspace
Codex (0.153.4, 0.161.0)	yes	from the installer	yes, after trusting them once with `/hooks`	none: each user runs the two `codex plugin` commands
Cursor (CLI 2026.10.01, verified from its plugin loader, not run live)	yes	yes	yes (Cursor converts them)	imports the plugin from Claude Code's `.claude/settings.json`

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 Code

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.

GitHub Copilot CLI

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.

VS Code (GitHub Copilot)

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.

OpenAI Codex

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/.

Cursor

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.

Python installer (`robotframework-plugins`)

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.

Agent	What lands where (files mode)	Coverage
Claude Code ≥ 2.1	`~/.claude/skills`, `~/.claude/agents`, `settings.json` hooks	full native
GitHub Copilot (VS Code ≥ 1.108)	reuses Claude Code paths (Copilot reads them natively)	full native
OpenAI Codex	`~/.agents/skills` per docs, `~/.codex/agents/*.toml`, `hooks.json`	full (hooks experimental, opt-in via `[features] codex_hooks=true`)
Cursor ≥ 2.4	`~/.cursor/skills`, `~/.cursor/agents`, `hooks.json` (namespaced matchers)	full native
OpenCode	`.opencode/skills`, `.opencode/agents` (`mode: subagent`), `.opencode/plugins/rf-agentskills.js` + hook scripts (or `~/.config/opencode/…`)	skills, subagents; edit validation, error hints and the environment report through the JS plugin (prompt context and the Stop reminder are not ported)
Project Goose ≥ 1.25	`~/.agents/skills` (Summon), `.goosehints` persona	skills; subagents folded into hints; hooks N/A
Claude Desktop	one upload-ready `rf-*.zip` per skill in `~/rf-agentskills-claude-desktop/`	skills via upload (Customize → Skills → Upload a skill; needs code execution); no subagents/hooks

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

Manual: copy skill folders

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.

Trust tiers

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.

No telemetry

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.

What you get

9 Skills

Skill	Type	Command (with the `rf-agentskills` bundle: `/rf-agentskills:<skill>`)	Description
Browser Library	library-reference	`/rf-web:rf-browser`	Web UI tests with Browser Library (Playwright); the default when no web library is chosen yet
SeleniumLibrary	library-reference	`/rf-web:rf-selenium`	Web UI tests with SeleniumLibrary (WebDriver, Selenium Grid) for suites that import `SeleniumLibrary`
AppiumLibrary	library-reference	`/rf-mobile:rf-appium`	Mobile app tests (Android/iOS native, hybrid, mobile web) with AppiumLibrary
RequestsLibrary	library-reference	`/rf-api:rf-requests`	HTTP/REST API tests with RequestsLibrary; the default when no API library is named
RESTinstance	library-reference	`/rf-api:rf-restinstance`	REST API tests with RESTinstance (`Library REST`): JSON Schema / OpenAPI-driven assertions
PlatynUI (preview)	library-reference	`/rf-desktop:rf-platynui`	Native desktop UI testing (Windows UIA, Linux AT-SPI2) via PlatynUI.BareMetal
Robot Framework language	language-guide + script	`/rf-core:rf-language`	Write and review tests (keyword-driven, data-driven, BDD), suites, `__init__.robot`, tags, user keywords, `.resource` and variable files in modern, version-gated syntax; `rf_conventions.py` script detects the project's conventions (requires robotframework). Not for Python keyword libraries
Python keyword libraries	library-guide + script	`/rf-core:rf-python-library`	Write and fix keyword libraries and listeners in Python: `@library`/`@keyword`, scope by state lifetime (TEST/SUITE/GLOBAL), type-hint conversion and custom converters, failures and logging, dynamic/hybrid APIs, listener API v3, libdoc; `check_library.py` script finds "contains no keywords", leaked imports, lost signatures and state kept in `TEST` scope before tests run (requires robotframework, Python 3.10+)
Setup	setup-guide	`/rf-core:rf-setup`	Install Robot Framework and libraries with uv, venv + pip or Poetry; fix environment errors (`ModuleNotFoundError`, wrong interpreter); project layout, CI

3 Specialized Agents

Agent	Purpose
RF Test Architect	Plan test suites, select libraries, design project structure
RF Debug Expert	Read-only diagnosis of failing or flaky runs: groups failures by cause, classifies them and returns a fix per cause (it does not edit files)
RF Migration Guide	Upgrade RF versions, migrate between libraries

Automated Hooks

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

Prerequisites

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)

Compatibility

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)

Upgrading from rf-agentskills

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.

More

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.

License

Apache-2.0

Navigation Menu

Repository navigation

About

Repository files navigation

Robot Framework plugins

Catalogue

Install

Which plugins

Plugin marketplace, per agent

Claude Code

GitHub Copilot CLI

VS Code (GitHub Copilot)

OpenAI Codex

Cursor

Python installer (`robotframework-plugins`)

Manual: copy skill folders

Trust tiers

No telemetry

What you get

9 Skills

3 Specialized Agents

Automated Hooks

Prerequisites

Compatibility

Upgrading from rf-agentskills

More

License

About

Releases

Packages

Contributors

Languages

Name		Name	Last commit message	Last commit date
.claude-plugin		.claude-plugin
.github		.github
bundles/rf-agentskills		bundles/rf-agentskills
docs		docs
eval		eval
installer		installer
legacy/rf-agentskills		legacy/rf-agentskills
openspec		openspec
plugins		plugins
schemas		schemas
scripts		scripts
security		security
src/rf_skill_eval		src/rf_skill_eval
templates/plugin		templates/plugin
tests		tests
.env.example		.env.example
.gitignore		.gitignore
.gitleaksignore		.gitleaksignore
.mcp.json		.mcp.json
CONTRIBUTING.md		CONTRIBUTING.md
GOVERNANCE.md		GOVERNANCE.md
LICENSE		LICENSE
README.md		README.md
RELEASING.md		RELEASING.md
SECURITY.md		SECURITY.md
pyproject.toml		pyproject.toml
uv.lock		uv.lock

Latest commit

History

Folders and files

Repository files navigation

Robot Framework plugins

Catalogue

Install

Which plugins

Plugin marketplace, per agent

Claude Code

GitHub Copilot CLI

VS Code (GitHub Copilot)

OpenAI Codex

Cursor

Python installer (robotframework-plugins)

Manual: copy skill folders

Trust tiers

No telemetry

What you get

9 Skills

3 Specialized Agents

Automated Hooks

Prerequisites

Compatibility

Upgrading from rf-agentskills

More

License

About

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Python installer (`robotframework-plugins`)