RobotCode

Appearance

What's New in RobotCode v2.6.0 ​

RobotCode v2.6.0 builds out a Robot Framework project's command line — new commands alongside sharper versions of the ones you already use — so working with a project means asking focused, structured questions instead of wading through raw .robot and .resource files, output.xml, or log.html. These project-aware commands discover tests, inspect finished runs, check code, explore keyword documentation, and debug a run. The work was driven by what AI agents need to operate a project without guessing, and a first version of chat plugins lets an agent drive the robotcode CLI directly — honoring your robot.toml, profiles, and Python environment, with more to come. It turns out a clean command line is exactly what developers and CI pipelines wanted too: readable Markdown at the prompt, and machine-readable JSON, SARIF, or GitHub and GitLab reports for pipelines. Separately, this release introduces the first experimental SemanticModel preview, a new foundation for deeper, more consistent Robot Framework analysis across RobotCode. A documentation refresh ties it together, explaining these workflows so agents and humans share the same resolved view of a project.

Inspect Robot Framework Runs from the Terminal ​

The new robotcode results command group lets you inspect finished Robot Framework runs straight from the terminal — the answers you'd normally hunt for in report.html or log.html, delivered as plain text instead. It is designed for quick local triage, CI logs, shell scripts, and AI-driven failure analysis, where compact summaries and structured output matter more than handing a whole result file to a chat session.

The command group covers the common result questions: summary gives a compact overview, show lists matching tests, log prints the execution tree, stats aggregates larger runs, and diff compares two result files. The active robot.toml profile is used to find the output file automatically, while -o/--output can point to a specific one.

Results can be filtered by status, tags, suites, tests, and long names, and --failed, --passed, and --skipped are available as quick additive shortcuts for common status filters. --search / --search-regex can narrow large runs by names, failures, keyword calls, arguments, log messages, and metadata.

Human text output is now Markdown. In an interactive colored terminal, RobotCode renders that Markdown with themed tables, headings, lists, status markers, highlighted matches, and terminal-friendly links. In a pipe, redirected output, or --no-color session, the raw Markdown is emitted as-is, which makes it useful for CI logs, pull requests, chat tools, and AI-agent workflows. --format json remains the stable payload for scripts, CI, editor integrations, and agents.

For deeper inspection, results log can include keyword or suite information with --keyword-info and --suite-info, and it can extract embedded artifacts such as screenshots into a directory.

bash
robotcode results summary
robotcode results show --failed --search login
robotcode results log --failed --keyword-info

For the full guide and more recipes, see Analyzing Run Results.

Searchable Project Discovery ​

Human discover output now follows the same Markdown-first approach as results: project trees, file lists, suite lists, test lists, task lists, tag summaries, and statistics render nicely in terminals while staying pasteable as plain Markdown when output is captured. JSON output is unchanged and records the applied search filter for scripts and agents.

robotcode discover also gains --search and --search-regex across all, files, suites, tags, tasks, and tests. That makes it easier for humans and agents to answer project-inventory questions without dumping the whole tree first: search can match names, long names, source paths, documentation, templates, timeouts, tags, suite documentation or metadata, and test body content such as keyword calls, arguments, assignments, control-flow conditions, and setup or teardown steps.

Parsing errors and warnings no longer clutter the default output. When a suite has parse issues, discover now prints a compact Diagnostics summary with the error and warning counts after the statistics, and --diagnostics lists the full messages on demand. JSON output still carries the complete diagnostics, so editors and agents are unaffected.

For the full discovery guide, including JSON output shapes and CI recipes, see Discovering Tests, Tasks and Suites.

CI-Ready Static Analysis Output ​

robotcode analyze code is now easier to use locally, in CI, and as an agent preflight check before running a suite. The default concise output prints diagnostics in source order, uses full severity names such as [ERROR] and [WARNING], and formats multi-line messages and related locations more clearly. Robot Framework tracebacks and long PYTHONPATH dumps are hidden by default so routine CLI output stays focused; use --show-tracebacks when you need the full diagnostic body.

For automation, the command now has structured output formats for JSON, SARIF, GitHub Actions annotations, and GitLab Code Quality reports. --output-file writes machine-readable reports directly to disk, and --full-paths switches between project-relative and absolute paths. The new --severity and --code filters let you narrow the reported diagnostics without remapping their severities, so the output, summary, and exit code stay aligned.

bash
robotcode analyze code
robotcode analyze code --severity error,warning
robotcode analyze code --output-format sarif --output-file robotcode.sarif

Path filtering is also stricter: passing a path such as tests/api no longer accidentally includes sibling folders like tests/api_v2. Workspace-level diagnostics now get an explicit .: source marker instead of appearing without any location context. Unused keyword and variable diagnostics now go through the same diagnostic modifiers as every other diagnostic, so -mi, -mX, and inline # robotcode: comments apply consistently.

For the full guide, including SARIF and CI recipes, see Analyzing Code.

A Command-Line Debugger, and a More Capable REPL ​

The headline here is a new command-line debugger for Robot Framework. robotcode robot-debug (alias run-debug) runs a real suite through the normal runner and pauses where you tell it to — a file and line, a keyword name, an embedded Breakpoint keyword, the first failure, or right at entry. Once it stops, you get a pdb-style prompt with the live call stack and variables, where you can step through execution, inspect and set variables, evaluate expressions, manage breakpoints, and run keywords in the paused context. It works on every supported Robot Framework version and runs in terminals, over SSH, and in containers where the VS Code debugger isn't an option — and an AI agent can drive it non-interactively to capture the exact state at the moment of failure.

bash
robotcode robot-debug --break login.robot:42 tests/
robotcode robot-debug --stop-on-entry tests/login.robot

The same debugger is available inside robotcode repl, but there it starts detached and the shell stays a shell: a failing keyword just prints its error and leaves you at the prompt. Attach it (.debug on, or start with --break) when you actually want to stop on a breakpoint, and the breakpoints you set survive toggling it back off.

Alongside the debugger, robotcode repl itself has grown into a far more comfortable scratchpad. It keeps command history across sessions, completes keywords, variables, and imports as you type, and handles multi-line blocks. .kw and .doc show the same keyword and library documentation the editor surfaces on hover, right in the terminal, in a scrollable viewer with search and clickable links. Imports work just like in a suite — type Library, Resource, or Variables at the prompt — ${_} holds the last keyword result, and .save exports a session as a runnable .robot file. A --plain mode keeps the output clean for scripts and AI-agent workflows.

For the full guide — every dot-command, the complete debugger command set, and installation extras — see the REPL and command-line debugger references.

AI and Agent Workflows ​

The commands in the sections above weren't built only for people at a keyboard — a big motivation was letting AI agents operate a Robot Framework project from the same structured, project-resolved output.

Chat Plugins for AI Agents ​

RobotCode now ships a set of chat plugins that teach an AI agent to operate a Robot Framework project through the project's own robotcode CLI, the way an experienced Robot Framework engineer would. The agent honors your robot.toml, profiles, and Python environment, so it works with the same resolved view of your project that the rest of RobotCode uses. The plugins are published as a marketplace, robotframework-agent-plugins, so any Open-Plugins-compatible agent — Claude Code, Codex, GitHub Copilot, and others — can install them once and reuse them anywhere. For example, you can ask it to:

  • "run the smoke tests with the ci profile" — runs them through the selected profile and reports pass/fail counts
  • "why did Login Works fail?" — inspects the existing run results with robotcode results
  • "what tests and tags exist?" — uses robotcode discover to resolve the real set (paths, profiles, variables, pre-run modifiers)
  • "what arguments does this keyword take?" — looks it up with libdoc against the installed libraries and local resources
  • "try this keyword" — runs it in the REPL

For agents running outside VS Code, the plugins call the robotcode CLI directly, so it needs to be installed in the project's Python environment.

Inside VS Code there's nothing to install: the extension bundles both the chat plugins — for GitHub Copilot Chat — and robotcode itself, making the bundled CLI available in the integrated terminal through VS Code's terminal shell integration, so the plugins work out of the box. They are enabled by default and can be toggled with robotcode.ai.enableChatPlugins.

If you would rather install the plugins from the marketplace inside VS Code, two new Command Palette commands — RobotCode: Add Chat Plugins Marketplace and RobotCode: Remove Chat Plugins Marketplace — register or remove the marketplace in your user-level chat.plugins.marketplaces setting without editing JSON by hand. Only the applicable command is shown depending on whether the marketplace is already registered. When you install the plugins this way, turn off robotcode.ai.enableChatPlugins so you do not run the bundled and marketplace copies at the same time.

For installation, marketplace setup, and troubleshooting, see Working with AI Agents.

VS Code Chat Tools Are Deprecated ​

The existing VS Code chat language model tools for Robot Framework keyword documentation, library documentation, imports, and environment details are now deprecated and disabled by default in favor of the CLI-based chat plugins described above. If you still rely on them during the transition, enable robotcode.ai.enableLanguageModelTools; the setting remains visible for now.

Cleaner Output in AI-Agent Sessions ​

RobotCode now recognizes common AI-agent environments and keeps terminal output easier to capture. Colors, paging, and REPL prompt enhancements are toned down by default in those sessions, so chat tools get clean text instead of terminal control sequences. Explicit CLI flags and environment variables still override the defaults; see AI-agent detection.

Experimental SemanticModel Preview ​

This release introduces the first experimental version of the SemanticModel, a new analysis foundation that RobotCode will use to understand Robot Framework files more deeply and more consistently.

This is the analysis-foundation part of the release, and it is intentionally not finished yet. The long-term plan is to replace the old analysis path with a single pre-computed model of the file: keyword calls, variables, imports, control flow, settings, references, and token meaning all resolved once, then reused by editor features. That should eventually mean less duplicated AST walking, fewer subtle differences between features, and better building blocks for things like completions, hover, rename, and future navigation features.

For v2.6.0, the SemanticModel is a preview behind an opt-in flag. Parts of the migration are already in place, and the migrated features are designed to behave the same as the default analyzer. This is still early in the migration, so the default analyzer remains the recommended path while the new model gets more real-world mileage.

Enable it in robot.toml:

toml
[tool.robotcode-analyze]
semantic-model = true

or in VS Code:

json
"robotcode.experimental.semanticModel": true

With the SemanticModel enabled, RobotCode can already statically resolve more nested variables such as ${DICT_${key}} and handle RF 7.4 KeywordName and KeywordArgument type hints for run-keyword detection.

Some editor features now have SemanticModel-backed paths:

  • Inlay hints read pre-resolved data instead of doing a second analysis pass.
  • Signature help can use already-resolved keyword data.
  • The "Open Documentation" code action can read keyword and token information from the model.
  • The "Create Keyword" quick fix and "Assign Result to Variable" refactor can use the keyword call's resolved namespace, library entry, and assignment state.

The intended result is that normal editor output stays the same while the internals get stronger. Dedicated equivalence tests already compare old and new paths across supported Robot Framework versions, but this is still a work in progress, not a stability promise.

The feature is disabled by default while it matures. If you are curious and enable it on your project, we would love to hear how it behaves for you, especially if you notice differences from the default analyzer. Real project feedback is exactly what will help turn this new foundation into the normal path later. The full robot.toml setting is documented in the configuration reference.

Documentation for Agent-Friendly Workflows ​

A lot of the release work went into documentation for those agent-friendly workflows too. There are new or heavily expanded guides for AI-agent workflows, run-result inspection, project discovery, static analysis, the REPL and command-line debugger, plus refreshed CLI and robot.toml references. The goal is the same as the tooling work: make the real project behavior easier to inspect, follow, and automate.

CLI and VS Code Polish ​

Smoother Test Explorer Refreshes ​

The VS Code Test Explorer is calmer and more responsive during active editing. It now avoids re-rendering the tree when discovered tests have not actually changed, batches bursts of file edits into a single workspace refresh, cancels in-flight discovery when newer edits arrive, and keeps expanded tree nodes open when external file changes are detected.

Newly added or removed tests in saved files now appear or disappear immediately without needing the refresh button. The same work also removes a startup edge case where AbortError could briefly show up as a workspace entry.

Cleaner Terminal Colors ​

CLI coloring now follows terminal conventions more closely. ANSI colors are auto-disabled when output is redirected to a pipe, file, log capture, or CI artifact, while NO_COLOR and FORCE_COLOR are respected. stdout and stderr are decided independently, so warnings can still stay colored when stdout is piped but stderr is still attached to a terminal. Explicit --color and --no-color still override auto-detection. This stream-based handling is separate from the AI-agent output tuning above: one reacts to where output goes, the other to who is reading it.

Control the What's New Notification ​

VS Code users can now turn off the update notification shown after RobotCode updates. The setting is available as robotcode.showWhatsNewOnUpdate under RobotCode > General. The What's New post is still there when you want it; the notification just no longer has to appear after every update.

Real robot.toml Examples in the Schema ​

The robot.toml reference and JSON schema now include real TOML examples and clearer inline documentation. The schema is also available from its new public URL, https://www.robotcode.io/schemas/robot.toml.json, so editor tooling can show more useful examples while you configure profiles, paths, variables, analysis settings, and runner options.

Bug Fixes ​

There are also a few focused fixes in this release:

  • CLI unused-variable diagnostics now treat variables starting with _ as intentionally unused, matching the language server behavior. (#593)
  • The environment-validation quick pick in VS Code now mentions the correct minimum Robot Framework version, 5.0 instead of the stale 4.1 text. Thanks to Danilo for the PR! (#603)
  • When VS Code's "4 Spaces Tab" setting is enabled, Tab now still accepts Copilot inline edit suggestions instead of always inserting spaces. (#566)
  • robot.toml now accepts max-error-lines = "NONE", matching Robot Framework's --maxerrorlines NONE spelling for showing the full error message. (#606)

Thank You ​

Thanks to everyone who reported issues and contributed ideas — and to everyone who uses RobotCode in their daily work. Your feedback drives every release.

For the full list of changes, see the Changelog.