Accel Orbit 2026-10-01 Update Details

With the 2026-10-01 update, the range of development you can hand to AI agents now extends much further into Java (the JavaEE development model). We have also reduced the effort needed to add the features required for development, and the rework needed before generated code runs.

Highlights of This Update

• You can have AI agents implement AI features that use IM-Copilot (iAP 2026 Autumn or later)
• Java code that uses platform features such as the common masters and caches is also generated in the correct way
• Generated code is less likely to fail at run time (database access, REST APIs, 2WaySQL, table definitions)
• On iAP 2026 Autumn or later, you can add the features you need for development just by selecting them in IM-Juggling
• The verification environment using Docker now supports iAP 2026 Autumn (with updated middleware versions)
• In the verification environment, user modules are included in the war just by placing them and building

The Suite of Features for AI-Assisted Development Is Now Called "Accel Orbit"

The suite of features for AI-assisted development on intra-mart Accel Platform now goes by a single name: Accel Orbit. The Accel CLI, the context for AI agents, the AI-native Development Support Feature (formerly the Development Support Module), the Visual Studio Code extensions, and so on are all components of Accel Orbit. You can now see the tools and assets we used to introduce under separate names as one whole.

We continue to use the term "AI-native development" to refer to the development style in which you hand a specification to an AI agent, have it generate artifacts, and proceed by repeating verification and fixes.

Build IM-Copilot AI Features into Business Applications

In projects for iAP 2026 Autumn or later, you can now have an AI agent generate code that builds IM-Copilot AI features into business applications. You can leave the implementation of mechanisms that answer based on internal documents, or that call business processing from AI, to the agent without researching them from scratch.

• AI agents — Build agents that receive instructions, process them, and return responses. You can also combine custom tools and knowledge search, and return results in a fixed format.
• RAG (retrieval-augmented generation) — Build a mechanism that splits and vectorizes documents such as internal materials, registers them, and answers based on search results.
• Tool Calling — Call business processing as functions from an AI assistant. The same code works whether you use OpenAI, Azure OpenAI Service, or Amazon Bedrock.
• MCP servers — Build servers that let external AI agents use features on iAP through MCP (Model Context Protocol).

Leave Java Code That Uses Platform Features to AI Agents

You can now generate Java code that works with the common masters such as users and organizations, login user information, localized messages, caches, custom configuration files, tokens for CSRF protection, and data propagation between modules, following the correct intra-mart conventions. Together with the authorization, account, and role support added in 2026-09-01, you can leave most of the platform features commonly used in business applications to AI agents.

You can also have AI agents implement, in Java, custom tasks (flow elements) used in IM-LogicDesigner logic flows. In the script development model (JSSP), you can now also generate code that uses caches.

The added skills are as follows.

Skill	What it does
java-im-copilot-agent-generator	Create AI agents with the IM-Copilot Agent framework (2026 Autumn or later)
java-im-copilot-rag-generator	Implement RAG (retrieval-augmented generation) using a vector store (2026 Autumn or later)
java-im-copilot-toolcalling-generator	Implement Tool Calling (function calling) for AI assistants (2026 Autumn or later)
java-im-mcp-generator	Implement MCP servers that run on iAP (2026 Autumn or later)
java-im-logic-generator	Implement custom IM-LogicDesigner tasks (flow elements)
java-im-master-usage	Work with the IM-Common Master (users, companies, organizations, items, and so on)
java-im-contexts-usage	Retrieve execution contexts such as login user information, and check authentication and administrator status
java-im-message-usage	Retrieve message properties (localization)
java-im-cache-usage	Use the cache API and create cache configuration files
java-im-configuration-generator	Create and load custom configuration files (configuration class, XSD, and XML)
java-im-secure-token-usage	Issue and verify secure tokens (CSRF protection)
java-im-propagation-generator	Send and receive data between modules with IM-Propagation
jssp-im-cache-usage	Use caches in the script development model (JSSP)

The skills for Java are placed when you choose to use Java when creating a project. The IM-LogicDesigner task skill is placed when you also select IM-LogicDesigner, the message skill when you also select internationalization, and the MCP server skill when you also select MCP.

The skill assets are published here.

Generated Code Is Less Likely to Fail at Run Time

We identified points that tend to cause problems when code actually runs and reflected them in the skills and conventions. This reduces rework such as code that builds but fails at run time, or that returns wrong results.

• Database access (im_mirage) — Generated code now avoids coding that leads to runtime errors or wrong results, such as how to write SQL for counting records, how fields without values are handled on update, return values when a search returns zero or multiple records, and how to build 2WaySQL loops and IN clauses. A validation script detects, in advance, errors caused by comments in SQL files.

• REST API (Web API Maker) — We stated explicitly that responses are wrapped in a container with error / data, and how to receive them on the screen side, so that screens receive the values correctly.

• Authorization — Added how to make roles and similar targets the subjects of authorization, and how to specify resources.

• IM-Workflow — Added how to register processing target plugins implemented in Java (where to place the configuration file and how to localize display names).

• Table definitions (DDL) — The naming of tables and columns, primary key design, file names, and recommended types for each database product are now an independent convention. Table definitions are generated under the same convention whether you work with tables from the script development model or from Java. A validation script mechanically checks whether they follow the convention.

• 2WaySQL (script development model) — Added cautions about error-prone patterns to the conventions.

  • Do not write comments in SQL files (text inside comments is interpreted as template syntax and causes runtime errors)
  • Build IN clauses according to the number of elements. Be careful, because passing an empty array can result in a search of all records
  • The escape character for LIKE searches, how to pass parameters when branching on dates, and how to build the SET clause of UPDATE statements

  Comments in generated SQL files are also detected by the post-generation validation script for screens.

Less Preparation Before You Start Developing

• Agent integration settings (MCP) — Only the connection targets you need are now included in the settings, according to the modules you use (connection targets for IM-LogicDesigner and IM-Workflow are added when you use them). The connection target and API key registered with accel login are embedded, so you do not need to copy them by hand.
• Test configuration file — When you use the script development model, the configuration file for unit tests (jest.config.js) is placed in advance. You do not need to prepare it when running tests with the Visual Studio Code extensions.
• Project dependency libraries — The dependency libraries for the helper tools used by skills (XML validation, BPMN parsing, and type checking) are now managed within each skill instead of the whole project. This reduces the development libraries included in the project's package.json.

Other Improvements

• IM-LogicDesigner — Added a caution about the setting that clears variables in loop tasks (do not target variables that accumulate results across iterations).
• Tenant environment setup — Added the fact that running a job implemented in Java right after hot deployment can fail, and how to work around it.
• Assets for GitHub Copilot — The description of the rule files (README) is now also placed in English and Simplified Chinese environments.

Add the Features You Need Just by Selecting Them in IM-Juggling

On iAP 2026 Autumn or later, you can now add the features you need for development from the application selection screen of IM-Juggling. You do not need to obtain and incorporate user modules (imm files) separately.

• AI-native Development Support Feature — Selecting "Accel Orbit" incorporates the AI-native Development Support Feature module under it. It was renamed from the Development Support Module (velbench).
• Debugger module — The debugger module, which is used to debug server-side scripts from VSCode, is incorporated when you select the "Module Development Support Library".

On 2025 Spring to 2026 Spring, incorporate the user modules (velbench-1.x.x.imm and im_eb_js_debugger-8.0.4.imm) with IM-Juggling as before. The steps after incorporating the AI-native Development Support Feature (creating the war file, deploying, and running the tenant environment setup) are the same for both versions.

The debugger module is built into the verification environment using Docker in advance, including environments for 2026 Autumn or later.

Use iAP 2026 Autumn in the Verification Environment

We updated the verification environment using Docker to support iAP 2026 Autumn, and updated the versions of the middleware and libraries along with it. The environment for 2026 Autumn is available on the 2026autumn-postgres / 2026autumn-oracle / 2026autumn-sqlserver branches (Selecting a Branch). The changes are basically the same for the standalone configuration and the cluster configuration.

The main changes from the environment for 2026 Spring are as follows.

Target	For 2026 Spring	For 2026 Autumn
intra-mart Accel Platform	2026 Spring	2026 Autumn (updated to the provided template)
Java runtime for Resin, Solr, and Cassandra	amazoncorretto:11.0.28-alpine	amazoncorretto:11.0.32-alpine (stays on Java 11)
PostgreSQL	postgres:17-alpine	postgres:18-alpine
Oracle Database Free	23.26.1.0	23.26.3.0 (the product name is still 26ai Free)
SQL Server	2025-latest	2025-latest (tag unchanged; linux/amd64 is now specified explicitly as the platform)
Node.js for war generation	node:22-alpine	node:22.23-alpine
Mailpit	v1.27	v1.31
Base image of the Test Execution Agent	Playwright v1.60.0-noble	Playwright v1.63.0-noble
Playwright MCP	0.0.36	0.0.82
PostgreSQL JDBC driver	42.7.7	42.7.13
SQL Server JDBC driver	13.4.0.jre11	13.6.0.jre11
Oracle JDBC driver	Placed manually (no version specified)	Placed manually (targets ojdbc11 23.26.3.0.0)

Apart from versions, we changed the following.

• Where PostgreSQL stores data — The mount point changed from /var/lib/postgresql/data to /var/lib/postgresql. PostgreSQL 18 data is stored in 18/docker under it. Database data from the environment for 2026 Spring cannot be used as is.
• Waiting for Oracle to start — To accommodate the initial database creation, the health check's startup grace period is now 20 minutes.
• Solr assets — Aligned with the assets for 2026 Autumn. The displayed version remains 9.6.0-1, but the two schema files for vector search have changed.
• Preparing dependencies for the Test Execution Agent — Instead of passing a compressed file of packages, node_modules and the matching browsers are now prepared when the image is built. A UTF-8 character encoding setting was also added.
• Additional user modules — Removed the former velbench and the debugger module imm files; the environment now uses the Accel Orbit and debugger that are built in as standard.
• Product settings — Updated the IM-Juggling project, the IM-FormaDesigner settings, and the IM-Copilot settings and schema to the 2026 Autumn templates.

Resin 4.0.67, Cassandra 1.1.12, Test Execution Agent 8.0.2, Java 17 for the Test Execution Agent, and Apache HTTPd 2.4-alpine are unchanged.

In the Verification Environment, Just Place User Modules to Include Them in the War

In the verification environment using Docker, placing user modules (.imm / .zip) under data/juggling/additional-modules and running juggling-build-war now automatically takes care of everything from incorporating them into the IM-Juggling project to generating the war.

• Replacement — If a user module with the same module ID already exists, it is replaced with the one you placed.
• Restoration on failure — If validating the configuration or generating the war fails after incorporation, the project is restored to its state before incorporation. No half-finished project is left behind.
• Build process — The war and static files are now built with the IM-Juggling library (@intra-mart/juggling-core).

We removed the extract-imm container, which extracted user modules directly into the war and static files. Switch to the method above.

To use this in an existing environment, update the repository to the latest state and rebuild the image with docker compose build --no-cache juggling-build-war.

Find the Information You Need More Easily (Documentation)

• The big picture of Accel Orbit — We added What Is Accel Orbit? to the top page, so you can check the positioning and components of Accel Orbit in one place. We also added "Accel Orbit" and "AI-native development" to the glossary.
• Installation procedures by iAP version — We rewrote Setup for the AI-native Development Support Feature and Server-Side Setup (debugger module) in Using Visual Studio Code into procedures by iAP version (2026 Autumn or later / 2025 Spring to 2026 Spring). You can choose the procedure that matches your environment.
• Renaming — Throughout the documentation, we changed "Development Support Module (velbench)" to "AI-native Development Support Feature" and noted the former name where needed. We also changed the stated supported iAP versions from "intended for 2026 Autumn or later" to "2025 Spring or later."
• Procedure for adding user modules — We rewrote Adding User Modules in the appendix of the verification environment using Docker to match the new method. It describes the replacement behavior, the fact that deleting a file does not remove the module from the project, and the restoration on failure. We also stated explicitly that rebuilding the war and static files removes files added directly to data/juggling/public and data/juggling/war, and that configuration files are overwritten in WEB-INF of the generated war.

• Note: Changelog entries up to 2026-09-01 are listed under the name used at the time of publication.

The Accel CLI Has Been Enhanced

• We made enhancements centered on internal performance improvements.
• We moved the location of the libraries used by the scripts that skills use internally to under .accel/. This keeps the libraries of the internal scripts from being listed in the projects you manage.
• Accel Platform 2026 Autumn (8.0.40) can now be selected.
• There are no changes to the CLI's interface.

How to Update from Pre-Release Assets Provided Earlier

Run the following command in the project root.

bunx @intra-mart/accel@latest update --asset-ref=production-v1

Caution

Do not omit --asset-ref=production-v1.

If accel update is not available, replace the assets with accel detach → accel attach.

To use the skills for Java added in this release, add Java in the feature selection when updating. The skills related to IM-Copilot and MCP servers are placed in projects for iAP 2026 Autumn or later.