Skip to content

About

Agent Plugins Marketplace for Robot Framework

Resources

Contributing

Security policy

Stars

1 star

Watchers

0 watching

Forks

Latest commit

 

History

236 Commits

Folders and files

Repository files navigation

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.

Quick start

  1. Add robotcode to the project's Python environment. The skills and hooks run it:

    uv add --dev "robotcode[all]>=2.8"      # or, in an active venv: pip install "robotcode[all]>=2.8"
  2. Add the plugins to your agent. You always need rf-core. Add one plugin for each library you test with:

    Library Plugin
    Browser, SeleniumLibrary rf-web
    RequestsLibrary, RESTinstance rf-api
    AppiumLibrary rf-mobile
    PlatynUI rf-desktop

    The examples install rf-web:

    Claude Code

    claude plugin marketplace add MarketSquare/robotframework-plugins#stable
    claude plugin install rf-web@robotframework-plugins       # brings rf-core

    GitHub Copilot CLI

    copilot plugin marketplace add MarketSquare/robotframework-plugins#stable
    copilot plugin install rf-core@robotframework-plugins
    copilot plugin install rf-web@robotframework-plugins

    OpenAI Codex

    codex plugin marketplace add MarketSquare/robotframework-plugins --ref stable
    codex plugin add rf-core@robotframework-plugins
    codex plugin add rf-web@robotframework-plugins

    VS Code (GitHub Copilot): in your user settings, set "chat.plugins.enabled": true, "chat.useHooks": true and "chat.plugins.marketplaces": ["MarketSquare/robotframework-plugins#stable"]. Then install rf-core and rf-web in the Extensions view. VS Code doesn't install rf-core for you.

    Cursor, OpenCode, Goose, Claude Desktop, or plain files for any agent:

    uvx robotframework-plugins install      # asks which agents; picks the plugins from your project's libraries
  3. Start a new agent session in the project. The skills load when a task needs them.

Install has the details: scopes, pinning a release, and each agent's limits.

Catalogue

Plugin Tier Status What it covers Libraries Maintainers
rf-core verified active Robot Framework syntax, environment setup, Python keyword libraries, test design and debugging subagents, and the validation hooks. Robot Framework @manykarim
rf-api verified active RequestsLibrary and RESTinstance skills for API tests. RequestsLibrary, RESTinstance @manykarim
rf-desktop verified active PlatynUI skill for desktop UI tests. PlatynUI @manykarim
rf-mobile verified active AppiumLibrary skill for Android and iOS tests. AppiumLibrary @manykarim
rf-web 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.

Release 5.0.0: the installer and every plugin below carry this version (v5.0.0 tag; RELEASING.md).

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

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, VS Code 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.

Each skill carries its plugin's prefix, for example /rf-web:rf-browser or /rf-core:rf-language. Up to 4.0.0, the rf-agentskills plugin used /rf-agentskills:rf-browser; update project instructions that still name that prefix.

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
  }
}

Add "ref" to the source to pin the marketplace to a release, for example "ref": "v5.0.0", or use stable for the latest release. Every plugin and the installer share one version, so a release tag pins all of them together. Older tags still install what they name, but receive no updates: v1.1.0 to v3.0.0 are rf-agentskills releases, and <plugin>--v1.0.0 the first separate plugins.

Claude Code

claude plugin marketplace add MarketSquare/robotframework-plugins
claude plugin install rf-web@robotframework-plugins                  # brings rf-core; --scope user (default) | project | local
# 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
# 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#stable"]
}

Use #v5.0.0 instead of #stable to pin one release. Then install rf-core and the technology plugins you need from that marketplace in the Extensions view.

  • Dependencies: VS Code doesn't install plugin dependencies (checked with 1.142), so install rf-core yourself.
  • Every profile: agent plugins are installed for your user, in every VS Code profile.
  • Project scope: chat.plugins.marketplaces is a user-only setting. In a check with VS Code 1.142, a committed .claude/settings.json that names this marketplace and enables a plugin neither added the marketplace nor offered the plugin, so each user adds the marketplace in their own settings.

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 v5.0.0
codex plugin add rf-core@robotframework-plugins                         # Codex doesn't install dependencies
codex plugin add rf-web@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, 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 v5.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 release 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-core.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.

Branches and tags

Ref Holds Moves
stable The latest release. Use this one. On every release
v<version>, for example v5.0.0 One release Never
main Every merged pull request: reviewed and checked by CI, but not released On every merge

Without a ref, agents follow the repository's default branch, main. Add #stable (or --ref stable) unless you want unreleased changes.

Trust tiers

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

  • verified: it has trigger tests and eval tasks for every skill and eval baselines on the current models that it keeps passing, and it passes the security gate and the keyword check.
  • 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 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 these plugins. It owns running, discovery, keyword documentation, result analysis, static analysis, robot.toml configuration, the REPL and the debugger; these plugins own 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 rf-core and the technology plugins you need. 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 changelog lists every release; its history part has 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.
  • AI_POLICY.md: what AI-assisted contributions must meet, and why RobotCode is the base for Robot Framework capabilities.
  • AGENTS.md: the guide for coding agents working in this repository.
  • 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

About

Agent Plugins Marketplace for Robot Framework

Resources

Contributing

Security policy

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages