Obeo AI for Capella — Release Notes

2026.9.0 is the first official release. Earlier versions are retained below as preview history. Each section describes changes relative to the preceding version; earlier capabilities remain available unless explicitly replaced.

1. 2026.11.0

1.1. New modeling and review capabilities

  • Focused Capella discovery. Inspect architecture and package entry points, search elements directly by name or type (including native actor labels), and restrict searches to a known subtree. Native Semantic Browser relationships and related diagrams can be inspected for selected elements without opening a diagram. See Inspect the Model.

  • Functional Chains and Operational Processes from existing exchanges. Create a connected, acyclic chain or OA process from semantic exchange IDs, or create it together with a view from exchange edges in a supported source diagram. Existing exchanges are reused. An XFCD is a separate representation; existing chains can be displayed and edited through compatible native palette tools. See Functional Chains and Operational Processes.

  • Native allocation management. Add or remove Component/Role-to-Function/Activity, Interface-to-Exchange Item, Component Exchange-to-Functional Exchange, Physical Link-to-Component Exchange, and Physical Part deployment allocations. Repeating an existing allocation state makes no duplicate change. Native eligibility, synchronization, deletion impacts and permissions apply. See Allocation Management.

  • Diagram layer control. Enable or disable layers exposed by the diagram’s native selector while preserving other layers. See Diagram Layers.

  • Review collections in Capella. Send exact inspected elements to a new or existing Mass Visualization or Mass Editing view without changing model content or source selection. Collections are temporary. See Review Collections in Capella.

  • Explicit session saving. Ask the assistant to save an identified Sirius session and report its resulting SYNC or DIRTY status. Saving covers the session’s pending semantic and representation changes, including manual changes. See Review and Save.

1.2. Focused inspection and agent workflows

  • Session discovery returns compact representation identities by default, with optional name/type filters and full diagnostic details on request. It does not open closed sessions.

  • Diagram inspection can request palette or content separately. Palette results retain native documentation and execution arguments. Palette edit results expose surviving created views and a reusable primary result view identifier.

  • EMF inspection defaults to compact nonempty, non-default attributes. Select properties, containment or relationships explicitly, and request full detail when empty or default values matter. Multivalued references and Capella searches/relationships support pagination. Omitted sections and partial pages must not be interpreted as empty or complete model values.

  • Agent guidance favors direct filtered lookup, reuse of returned identities, and verification from successful tool results. Additional reads resolve missing or uncertain evidence instead of routinely describing the whole model after each edit. These changes reduce unnecessary context; no fixed token or latency reduction is claimed.

1.3. Editing contracts and upgrade actions

  • Atomic palette batches. All steps of sirius_apply_palette_tools now share one transaction and undo entry, including optional naming. A failed transaction rolls back the whole batch and returns no usable identifiers for rolled-back edits. Inputs must already exist; dependent creation uses subsequent calls.

  • Stateless contextual creation. capella_execute_element_creation_actions replaces the singular creation tool. Supply one existing parent and ordered steps with readable actionKey values and optional names. Discovery can be skipped when the exact key is known. The batch is atomic, undoable and unsaved, and creates no diagram views. The old creation computeId/actionId form is removed; transition tokens are unchanged.

  • Atomic element documentation batches. capella_set_element_description now requires a nonempty steps array of {target, documentation} updates, including for one element. Updates share one backend request and one undoable command, roll back together on failure, and remain unsaved. The Java setter is now setElementDescriptions, with JSON-RPC route capella/model/setElementDescriptions; callers must migrate to the typed batch request.

  • Other batches retain partial-success semantics. Representation, diagram, EMF and Capella model-edit batches stop at the first failed step and retain earlier successful changes. Individual chain/allocation steps are transactional; their enclosing batch is not. Failed MCP batches are reported as tool errors with available step results. See recovery instructions.

  • Custom clients must refresh contracts. Session and EMF inspection results are more selective and compact. Refresh cached tool schemas, handle pagination and omitted sections, and update parsers and edit requests. Follow Upgrade to 2026.11.0.

1.4. Installation, delivery and diagnostics

  • Target platform and upcoming Capella installation support. Capella 7.1 is the main target version. Installation is also supported on Capella 7.0, Capella 6.1 and the upcoming Capella 2026.11.0 (technical version 7.2.0), including SMW and native macOS application layouts. The installer selects the matching bundled dependency repository and licensing/ELK versions. MCP and CLI tools require Java 21. See Supported environment.

  • Token-bearing automation connections. Every connection to the Eclipse-side server requires its runtime token, including automatically approved local connections. Discovery excludes and removes old tokenless metadata. Update and restart both the Automation Server and agent tools; this token is separate from an optional MCP HTTP bearer token.

  • Immediate license diagnostics. License refusal is reported to the assistant without waiting for the Capella dialog to close. See Troubleshooting.

  • Delivery artifacts. SHA-256/SHA-512 checksum files accompany delivery archives. CycloneDX software bills of materials and a generated Java API catalogue are separate delivery outputs. The agent archive continues to embed the guidance templates; public product guides remain online.

  • Client documentation. Configuration examples include Tencent Workbuddy. Guides distinguish reported connection trials from setup examples and from successful guidance loading or modeling. Client capabilities must be checked on the exact application and version used.

1.5. Remaining limitations

The read-only profile filters tools; it is not a guarantee against every side effect. Sequence/Scenario layout and event-ordering edits remain manual, and some dialog-based native actions remain unsupported. See Known Limitations. Atomic rollback does not establish the outcome of a lost connection: inspect uncertain effects before retrying. Saving does not establish a Team for Capella commit or requirements satisfaction.

2. 2026.9.0

2.1. New features

  • Optional Capella startup prompt. Clients that expose MCP prompts can select capella_init to insert the packaged initial instructions into the conversation. The prompt itself does not connect to Capella or load the extended guidance; follow its instructions before starting a modeling task.

  • Capella top-down transitions through MCP. Discover the transitions available for a semantic selection, then execute the chosen action. Supported families include functions, interfaces, data, state machines, actors, capabilities, and transitions between logical components, physical components, and configuration items, where applicable in Capella. Transitions do not automatically save the session.

  • Explicit selections for palette tools. Discover candidates and preselected elements, then supply the selection without opening the tool’s dialog. Supported tools include function allocation from a LAB diagram.

  • Incremental EMF model exploration. Navigate from session roots to properties and references, with filters for feature kind, feature name, element name, and metaclass. Results expose parent, type, and child-presence information without recursively expanding the entire model. Returned semantic identifiers can be reused across calls.

  • Capella guidance and Arcadia context delivered through MCP. Initialization instructions, dedicated resources, and the capella_get_agent_guidance fallback tool provide the agent’s operating guidance. The normal setup no longer requires copying a complete AGENTS.md into each workspace. Actual guidance retrieval depends on the MCP client.

  • Simpler AQL input. Expressions without an AQL prefix receive one automatically.

2.2. Reliability and diagnostics

  • Capella edge-tool preconditions now use the same source, target, view, and diagram context as native Sirius execution, correcting selection-candidate discovery for edge tools.

  • Structured MCP results are normalized as JSON objects, with matching text content. JSON-RPC error handling and MCP failure reporting are improved.

  • MCP and JSON-RPC call logging, consistent CLI/MCP logging configuration, and optional rotating log files. In the final configuration, file logging is disabled by default; warnings and errors remain on stderr.

  • Clearer creation computeId lifecycle: single use, expiration after two minutes, and actionable errors prompting clients to repeat discovery.

  • Fixes for palette tool availability, failed transition reporting, and logical actor counts.

2.3. Installation and documentation

  • Public documentation moves to Antora. The web documentation replaces the former CI-generated guide PDFs and brings the quick start, user manual, installation guide, LLM client configuration, MCP reference, feature catalogue, and release notes together. PDF and Eclipse exports remain available through the local Antora scripts.

  • Product guides are available online. The agent archive no longer includes the public AsciiDoc guide sources under docs/product/. Use the online-help links in the packaged README and installers. Agent guidance templates, client resources, examples, and experimental JShell documentation remain packaged.

  • Guides describe modeling tasks and capabilities. Working with Capella covers conversation startup, guidance loading, model and diagram changes, realization links, and review and save workflows. Features presents capabilities and example requests.

  • Installation requirements and access are documented. The supported environment covers Windows, Linux and macOS, host permissions, agentic client requirements, and external connections. The installation guide explains stdio/HTTP access rights, server profiles, and how to request and install a personalized license. Get Obeo AI for Capella explains how to obtain download links from your Obeo contact.

  • Client setup includes a working VS Code Windows example. The stdio configuration launches the MCP server through cmd.exe with an explicit working directory and includes startup diagnostics. Generic examples use <installation-folder-absolute-path>, Windows executable names, and documented Linux/macOS equivalents. The VS Code trial validates stdio setup; it does not establish HTTP compatibility or a fixed tool count.

  • Agent guidance now describes Functional Chain construction through Functional Chain Description palette tools and recommends discovering representation types from the target element’s context.

  • Capella 7.1.0 becomes the documented target version, while installation paths for 7.0.1 and 6.1.0 remain available. MCP and CLI tools require Java 21 with every supported Capella version. Launchers can reuse Java 21 bundled with a standard Capella 7.1.0 distribution.

  • ELK and its dependencies install from the bundled repository for Capella 7.0.1 and 7.1.0; the 6.1.0 installation path continues to skip ELK. Distribution archives now extract tools/ and updateSite/ directly at the extraction root.

  • Expanded quick-start and user guides cover modeling from requirements, using Arcadia transitions, and selecting the optional capella_init startup prompt in supporting clients, with a Claude Code example. User Manual navigation follows the modeling guide’s reading order; unfinished requirements, scaling, administration and migration pages are hidden from navigation.

2.4. MCP configuration

The analysis server profile has been removed. Use the default edit profile for the full tool catalogue, including all 11 legacy helpers, or read-only for inspection tools. Existing launch configurations using --profile analysis must be updated before restarting the server. Tool intent metadata is unchanged. Legacy tools are available only under edit; they are not guaranteed to leave data unchanged. The read-only profile now excludes all 11 legacy tools and exposes 20 active inspection tools. Deprecated tools conservatively publish mutating: true metadata.

2.5. Editing behavior

  • More MCP edits remain pending until you save. Updating Capella element descriptions or realization links, renaming elements through diagram views, creating representations, and updating diagram descriptions no longer automatically save the Sirius session. Adding semantic resources and selecting viewpoints during these operations also leave the session unsaved. Review the changes and explicitly save the session when ready.

2.6. Licensing and notices

  • Updated the End User Licence Agreement documentation and packaged HTML license text.

  • Standardized source, script, build/configuration, and bundle/feature copyright notices on the complete 2026 Obeo notice. Agent contribution guidance now prescribes the same notice.

2.7. Documented limitations

The read-only profile filters the available tools; it does not guarantee that model and session data remain unchanged. Some inspection operations can activate viewpoints or open diagram editors, and AQL may invoke Java services with side effects. See the read-only profile limitation.

The EMF editing contract now explicitly states that create_new_element accepts Ecore metaclasses only; it cannot create Capella elements. set_properties can update writable features of existing Capella elements, while rename and move operations are Ecore-specific. Component Exchange to Functional Exchange allocation remains unsupported through MCP; use Capella’s Allocated Functional Exchanges property field. These are clarified existing limits.

Editing Sirius Sequence and Capella Scenario diagrams remains limited. Creating, opening, and inspecting these representations, and making edits that do not affect events or their ordering, are supported. Layout changes and changes to semantic ordering must be performed in Capella. Some actions that open dialogs may still fail with Invalid thread access. This documents existing limitations rather than adding capabilities.

3. 2026.7.0

3.1. New features

  • Multiple operations in a single MCP call. Batch tools cover palette creation, representation management, diagram operations, EMF inspection and edits, and selected Capella edits. The main tools are sirius_apply_palette_tools, sirius_manage_representations, sirius_manage_diagrams, emf_describe_model, emf_apply_edits, and capella_apply_model_edits.

  • Sirius collaboration diagnostics. Session and representation results expose collaborative state and lock information, with clearer edit-denial reporting and handling of frozen representations. Diagram refresh is added to MCP operations.

  • Grouped palette descriptions make the available tools easier to discover within a diagram description.

3.2. Distribution and documentation

  • Obeo license management, Obeo AI for Capella product branding, and the associated EULA are integrated into the distribution.

  • Legacy preview features are removed during installation.

  • A feature catalogue and tool deprecation metadata identify recommended replacements. Client and developer documentation are separated.

  • HTTPS bearer authentication receives tests and documentation. This strengthens a transport already present in 0.7.0.

3.3. API and tool contract changes

  • Several single-operation tools are replaced with batch tools. LAB wrappers that duplicated Sirius operations are removed in favor of the generic tools.

  • Module, artifact, and Java package identifiers move to fr.obeo.ai.*. Existing Java integrations must update their references.

  • Batches stop at the first error. Earlier successful changes may remain applied; a batch call does not provide automatic rollback of the entire operation.

4. 0.7.1

4.1. New features

  • EMF MCP tools backed by Sirius sessions. Inspect types and properties; create, rename, update, move, and delete elements. This MCP surface complements the existing EMF Java API.

  • Discovery and execution of Capella semantic creation actions. Create child elements without creating a view in a diagram.

  • Richer Sirius creation-tool descriptors expose tool identifiers and parameters before execution.

4.2. Reliability and installation

  • Fixes for diagram node creation and shared diagram handles. Diagram creation selects the shared analysis in collaborative contexts.

  • Better preservation of semantic identifiers, use of session identifiers when available, and more resilient runtime metadata cleanup.

  • Incompatible automation protocol versions are detected and rejected.

  • Fixes for null selectors and Capella inspection errors. Installation scripts support updates, distribution packaging is simplified, and JShell is explicitly documented as experimental.

4.3. API and tool contract changes

Representation and viewpoint identifiers are clarified, internationalized labels are supported, and opening an existing diagram is explicitly separated from creating a representation. Clients using the previous names or parameters must be updated.

5. 0.7.0

This section describes the capabilities available in 0.7.0 as the baseline for the later releases listed above.

  • Connect assistants to a running Capella instance. An aggregate Capella MCP server exposes Sirius capabilities, stdio and HTTP/HTTPS transports, runtime and project discovery, and configurable tool access.

  • Explore models and diagrams. Inspect sessions and Capella models, discover representation types and compatible targets, read and update the active selection, and run read-only AQL queries.

  • Create and edit models and diagrams. Create Capella projects, create and open representations, apply palette tools, and create logical components, actors, functions, and exchanges.

  • Analyze impact. Find semantic references and affected representations, with initial specialized tools for exploring logical components, allocations, interfaces, and dependencies. Some specialized analysis helpers are subsequently deprecated in 2026.7.0.

  • Document models and maintain traceability. Read and update element and diagram descriptions, resolve the component behind a Part, and create realization links.

  • Arrange and export diagrams. Arrange diagrams, export images, and use optimized ELK layout for Capella.

  • Use programmatic integrations. Java clients for Sirius, Capella, and EcoreTools, CLI commands, reflective EMF access, and a JShell environment with examples.

  • Control automation connections. Connection confirmation, token-based authentication for local JSON-RPC, and a preview validity window.

  • Install offline. A unified p2 update site, Windows and Linux/macOS archives, installation scripts, and a PDF installation guide. Capella 6.1 compatibility is added alongside the Capella 7.0.1 setup.