AI-KM Update Turns Agents Into Reusable Software Assets

When large language models first captured public attention, the most striking demonstrations were improvised: a clever prompt here, a tool call there, stitched together in a chat window and gone the moment the conversation ended. What looked like magic in a demo, however, proved stubbornly difficult to reproduce in practice. A research team writing in the Elsevier open-access journal SoftwareX has now released version 6.9.24 of AI-KM, a knowledge management platform that attempts to solve one of the most quietly urgent problems in modern artificial intelligence: how to turn an agent from a fragile, ad hoc assembly of prompts and settings into a portable, verifiable, reusable software asset.

The update, described by Haolin Wen, Yidan Li, Jingwei Xie, Yuqi Li, Shuai Liu, and their collaborators, introduces three tightly linked capabilities: Agent Preset, Agent Swarm, and Agent Scaffold. All three run on the same execution engine and message model, which means a single agent definition can move seamlessly between a one-on-one conversation, a multi-agent group discussion, and a large-scale batch-processing task. The platform itself is built on TypeScript, Vue3, Node.js, Electron, and Pinia, runs on Windows 10/11 or Linux with Node.js 20 or later, and is distributed under the PolyForm Noncommercial License 1.0.0 through a public Git repository.

The first capability, Agent Preset, tackles a problem that anyone who has tried to share an AI agent will recognize. In most existing systems, a usable agent is assembled from scattered pieces: system prompts buried in chat histories, model and decoding parameters hidden in interface configurations, tool permissions spread across code branches, knowledge sources referenced indirectly, and execution budgets that exist only as unwritten assumptions. When these elements live in different places, the agent cannot be migrated as a complete unit, and its capability boundaries cannot be explicitly verified. Reuse degenerates into copying and pasting prompts, while the agent’s actual scope may drift silently across execution environments.

Agent Preset consolidates everything into a single declarative specification stored as an independent file in an open, text-based format. The specification captures the model provider, model, and temperature that define the inference backend; system instructions that carry the task specification and output constraints; a capability configuration combining capability slots, a tool whitelist, MCP services, and knowledge base files; a set of callable skill assets; execution controls such as the maximum reasoning steps for a single task; a context strategy determining whether conversation history is inherited; and a prompt assembly mode that may be free-form text or segmented templates. Role definitions are integrated directly into the system instructions to avoid semantic conflicts between separate role descriptions and prompts.

The most technically consequential element is runtime capability enforcement. Agent capabilities are represented through fourteen semantic capability slots, describing what the agent can do from the user’s perspective, and the enabled set is explicitly enumerable. The slots map onto concrete tools: planning maps to update_plan, knowledge base access to kb_search, code execution to run_python, command execution to shell, web search to web_search, file operations to read_file and write_file, and so on. Any invocation outside the enabled set is rejected at runtime, not merely discouraged. This distinction matters because prompt-level instructions alone are vulnerable to hallucinated or unauthorized tool calls; enforcing boundaries in the execution engine reduces that risk structurally rather than hoping the model behaves. Skills can be incorporated in two ways: on-demand loading, which provides only the skill list and retrieves detailed instructions when invoked, saving context-window space, or inline loading, which inserts selected skill instructions directly into the system instructions for a more fixed and predictable execution context.

The second capability, Agent Swarm, addresses the coordination overhead of multi-agent collaboration. Common approaches rely on role assignment, message protocols, or centralized orchestrators, all of which assume users must design the communication structure in advance. When models have heterogeneous capabilities and task boundaries are ambiguous, these structured protocols can become the most fragile component of the system. Agent Swarm takes a deliberately different path: instead of introducing a standalone collaboration module, it implements multi-agent collaboration as an interaction mode within the conversational interface itself. Swarm members directly reference existing Agent Presets, and collaboration is achieved through group-chat history injection, task-level context accumulation, and flexible @mention-based invocation. The collaboration process remains a searchable, logged, and traceable conversation, and member responses follow the same message schema as single-agent responses, so they directly inherit existing conversational capabilities including stop control, runtime guidance, and token-usage tracking.

Formally, a swarm run is represented as a tuple containing the participating Agent Presets, a speaking order, a context-propagation function, and a convergence strategy. A swarm task unfolds in three stages: response generation, in which members respond in sequence or according to an explicitly mentioned subset; context propagation, in which the formal responses of preceding members are injected into the prompts of subsequent members as member-content pairs; and convergence, in which the host produces a summary or returns the consolidated result. The system provides three execution modes, All Respond, Moderator-mediated, and Debate, together with the targeted @mention channel. Typical use cases include multidisciplinary review of the same proposal, targeted follow-up questions to a specific expert, and multi-round debates followed by a neutral synthesis when explicit disagreements arise.

The third capability, Agent Scaffold, confronts the fragmentation of batch processing. Repetitive tasks over real-world operational data, such as row-by-row reasoning, file-by-file extraction, and multi-site data collection, are often implemented as multiple independent tools with overlapping functionality, each with its own configuration model, persistence format, and result view. Agent Scaffold unifies these into a three-dimensional orthogonal configuration space: source times executor times aggregation. The choices along the three dimensions are independent, so changing the execution method or output format for the same set of task rows requires only a configuration change rather than a reimplementation. The executor becomes a replaceable dimension, allowing full agent sessions, tool-free LLM inference, and structured extraction to be compared within the same task. Four presets cover common patterns: Batch Agent Execution for repetitive processing of large heterogeneous inputs, Table-oriented Reasoning for row-by-row analysis with structured output, File Collection for standardized extraction from distributed files, and Link Collection for multi-site collection with unified tabular output.

Reliability mechanisms make the scaffold robust against the dynamic nature of real-world data. Normalized fingerprints provide robust alignment between results and task rows while supporting incremental change detection, so results remain associated with the correct task rows even after additions, deletions, or modifications to the source table. Layered fault-tolerance settings support row-level retries and result replacement. Multi-round execution takes three forms: replay, in which the same batch of rows is rerun under a different configuration for comparison; chained expansion, in which structured outputs from one round are expanded into a new set of task rows to support staged workflows such as extraction, analysis, and review; and cross-round references, in which instructions can refer to results produced in previous rounds. In an illustrative scenario, a research team monitoring retraction activity in a research field collects records from journal announcements, institutional notices, and database exports, then switches to lower-cost tool-free inference for row-by-row classification; when sources change, the system resynchronizes and reruns only newly added or modified rows.

The implications extend from individual users to organizations and the research community. For users, the three capabilities turn prompt-engineering practices into manageable software assets: domain expertise can be packaged once and shared as reusable files, assessments from multiple expert perspectives can be organized into a single traceable collaboration, and materials that previously required manual item-by-item processing become batch operations that can be rerun, compared, and traced. For organizations, presets, skills, knowledge bases, and ontologies together form a knowledge-asset framework in which expert judgment is captured in executable form and agent assets are versioned as plain-text files, managed with processes similar to those applied to source code. For the research community, the work contributes three design mechanisms: runtime-enforced capability boundaries, conversation-native multi-agent collaboration for general-purpose tasks, and an orthogonal configuration space that unifies heterogeneous batch-processing tools while preserving behavior through presets. Future work will pursue shared memory management for swarms, systematic evaluation of collaboration modes through controlled experiments, and integration of domain-specific tool sets for office documents, scholarly information retrieval, and disciplinary databases, so that domain experts can package and distribute end-to-end task capabilities as reusable software assets.

Subject of Research: AI-KM update turns AI agents into reusable software assets

Article Title: Version 6.9.24 – AI-KM: Agent Preset, Agent Swarm, and Agent Scaffold

Article References: Wen, H., Li, Y., Xie, J., Li, Y., & Liu, S. (2026). Version 6.9.24 – AI-KM: Agent Preset, Agent Swarm, and Agent Scaffold. SoftwareX, 36, Article 103123. https://doi.org/10.1016/j.softx.2026.103123

Image Credits: AI Generated

DOI: 10.1016/j.softx.2026.103123

Keywords: AI-KM, Agent Preset, Agent Swarm, Agent Scaffold, LLM agents, SoftwareX, Version, Agent, Preset, Swarm, Scaffold, scientific research