IronEngine: Towards General AI Assistant

Xi Mo

cs.AIMar 9, 2026

IronEngine: Towards General AI Assistant

Authors: Xi Mo

Organizations: NiusRobotLab

Abstract

This paper presents IronEngine, a general AI assistant platform organized around a unified orchestration core that connects a desktop user interface, REST and WebSocket APIs, Python clients, local and cloud model backends, persistent memory, task scheduling, reusable skills, 24-category tool execution, MCP-compatible extensibility, and hardware-facing integration. IronEngine introduces a three-phase pipeline -- Discussion (Planner--Reviewer collaboration), Model Switch (VRAM-aware transition), and Execution (tool-augmented action loop) -- that separates planning quality from execution capability. The system features a hierarchical memory architecture with multi-level consolidation, a vectorized skill repository backed by ChromaDB, an adaptive model management layer supporting 92 model profiles with VRAM-aware context budgeting, and an intelligent tool routing system with 130+ alias normalization and automatic error correction. We present experimental results on file operation benchmarks achieving 100% task completion with a mean total time of 1541 seconds across four heterogeneous tasks, and provide detailed comparisons with representative AI assistant systems including ChatGPT, Claude Desktop, Cursor, Windsurf, and open-source agent frameworks. Without disclosing proprietary prompts or core algorithms, this paper analyzes the platform's architectural decomposition, subsystem design, experimental performance, safety boundaries, and comparative engineering advantages. The resulting study positions IronEngine as a system-oriented foundation for general-purpose personal assistants, automation frameworks, and future human-centered agent platforms.

Figures & tables

Figure 1: Simplified trajectory of AI agent research and product evolution relevant to IronEngine. Blue nodes indicate research milestones; orange nodes indicate product-oriented systems.

Figure 2: Overall architecture of IronEngine showing the four-layer design: interaction surfaces (top), unified orchestrator (middle), capability modules (lower-middle), and environment interfaces (bottom).

Evidence location	Capability	Interpretation
main.py	Multi-entry runtime	ui , api , cli modes under one engine
docs/API.md	Service interfaces	REST, WebSocket, Python client surfaces
docs/ARCHITECTURE.md	Pipeline design	Plan/Review/Execute, skills, memory, MCP
pipeline.py	Three-phase orchestration	Discussion, Switch, Execution; 17 callbacks
tool_router.py	24-category dispatch	Routing, auto-correction, 130+ aliases
memomap.py	Hierarchical memory	Session/pipeline/summary/refined entries

Table 1: Mapping between major system claims and engineering evidence in the project

Figure 3: IronEngine desktop UI. The left panel exposes model and execution configuration with Planner/Reviewer/Tools model selectors. The right area supports conversation with inline thinking blocks, tool execution badges, and quality score indicators.

Figure 4: IronEngine three-phase pipeline. Phase 1 (Discussion): Planner and Reviewer collaborate on plan quality without tool execution. Phase 2 (Model Switch): VRAM-aware transition from discussion models to execution model. Phase 3 (Execution): Executor runs tools iteratively until task completion.

Domain	Tool types	Description
File system	file_ops, file_write, archive, binary_read	List, copy, move, rename, delete files; create/overwrite files; compress/extract archives; read binary file metadata
Web	web_search, web_read, browser	Multi-engine search with captcha handling; HTTP content extraction with OCR fallback; full browser automation via CDP
Communication	wechat	Automated messaging, file transfer, sticker sending, and message reading for WeChat
Desktop GUI	gui_auto, app_control, auto_input	Mouse/keyboard automation; window management and UIA element interaction; automated form input
Media	image_gen, image_read, speech_tts, speech_stt, video_analyze, audio_analyze	Image generation and vision analysis; text-to-speech and speech-to-text; video frame analysis with audio transcription
System	cli, classify, network	Sandboxed command execution; text classification; WiFi, FTP, ping, DNS, port scanning

Table 2: IronEngine tool categories organized by functional domain

Figure 5: Tool dispatch flow in IronEngine. Model output is parsed, types are normalized through 130+ aliases, auto-corrected if mismatched, and dispatched with multi-layer fallback chains.

Figure 6: Web search four-strategy fallback chain. Each strategy is attempted in order; the first success terminates the chain.

Figure 7: Memory hierarchy and lifecycle in IronEngine. Session and pipeline entries are consolidated through two merge strategies into daily summaries and refined long-term knowledge. Context retrieval selects the most relevant entries (2 positive + 1 negative examples) for each new request.

Tier	Tool docs	SOUL	Strategy
Small ( $\leq$ 10B)	$\sim$ 733 tok	$\sim$ 44 tok	Identity only; minimal tool descriptions
Medium (10–25B)	$\sim$ 1964 tok	$\sim$ 623 tok	Core SOUL sections; standard tool docs
Large ( $>$ 25B)	$\sim$ 2236 tok	$\sim$ 1309 tok	Full SOUL with all behavioral sections; comprehensive tool docs

Table 3: Tiered prompt system based on model size

#	Task description	Time (s)	Rounds	Result	Key observations
1	List files in a directory with spaces and quotes in path	379	2	PASS	Path with special characters correctly handled; file_ops auto-selected
2	Move a file from one directory to another (cross-drive)	311	2	PASS	Two-path parsing with “to” separator; cross-drive move succeeded
3a	Create a new text file with specific content	421	2	PASS	file_write tool correctly dispatched; content verified
3b	Delete a specific file by path	430	2	PASS	file_ops delete operation; existence verified pre/post deletion
Total		1541	8	4/4	Mean: 385s per task; 2 rounds per task average

Table 4: File operation benchmark results. All tasks achieve 100% correctness (4/4 PASS).

Figure 8: Distribution of execution time across pipeline phases for each benchmark task. Model inference (Planner + Reviewer + Executor) dominates total time, while actual tool execution completes in under 2 seconds. The model switch phase is constant at

\sim

27 seconds.

Correction type	Count	Success	Notes
cli $\rightarrow$ file_ops	12	100%	Path pattern detected
browse $\rightarrow$ browser	3	100%	Alias normalized
web_read $\rightarrow$ browser	2	100%	JS-heavy site detected
Alias normalization	47	100%	130+ aliases
No correction needed	89	100%	Direct dispatch

Table 5: Tool routing auto-correction statistics

Phase	Peak VRAM	Notes
Discussion (Planner)	$\sim$ 17.5 GB	qwen3.5:27b Q4 quantized
Discussion (Reviewer)	$\sim$ 13.0 GB	gpt-oss:20b Q4 quantized
Model switch	$\sim$ 2 GB	Post-unload residual
Execution (Executor)	$\sim$ 17.5 GB	Reuses Planner or dedicated model
Tool translation	$\sim$ 2.5 GB	phi4-mini:3.8b

Table 6: VRAM usage by pipeline phase

	IronEngine	ChatGPT	Claude	OpenClaw	NanoClaw	IronClaw	Cursor	AutoGen	Open Interp.
Local models	S	W	W	S	S	M	M	M	S
Multi-role pipeline	S	W	M	W	W	W	M	S	W
Tool categories	S (24)	M	M	M	W	M	M	M	M
Memory system	S	M	W	M	W	W	W	W	W
Skill learning	S	W	W	M	W	W	W	W	W
Task scheduling	S	W	W	M	W	M	–	M	W

Table 7: Detailed capability comparison with representative AI assistant systems. Ratings: S =Strong, M =Medium, W =Weak, – =Not applicable.

Model	Params	Score	Time (s)
cogito:8b	8B	100	10.5
cogito:14b	14B	100	13.5
lfm2:24b	24B	100	33.7
qwen3.5:27b	27B	100	50.2

Table 8: Cross-model tool awareness test results. All models achieve perfect tool-type identification with IronEngine’s tiered prompt system.

Model Config	Scenario	Quality Score	Time (s)	Result	Observations
cogito:14b + cogito:8b	Shell command execution	0.20 $\to$ 0.85	139.6	PASS	Reviewer feedback improved plan specificity
cogito:14b + cogito:8b	PDF processing	0.15 $\to$ 0.80	152.2	PASS	Two rounds needed; tool selection corrected
cogito:14b + cogito:8b	WeChat messaging	0.10 $\to$ 0.85	81.8	PASS	Skill-augmented execution; fastest completion
cogito:14b + cogito:8b	Story creation	0.85 (R1)	321.4	PASS	Generative task; passed on first round
qwen3.5:27b + cogito:8b	MCU comparison	0.75 (R1)	172.0	PASS	Web search required; larger Planner beneficial
qwen3.5:27b + cogito:8b	Travel planning	0.20 $\to$ 0.40	309.8	FAIL	No network search available in test env

Table 9: Full pipeline integration test results across model configurations and scenarios. Quality scores show Round 1 (initial)

\to

Round 2 (after Reviewer feedback) progression.

Figure 9: Planner–Reviewer quality score progression. Red bars show initial Round 1 scores; green bars show final scores after Reviewer feedback. The Reviewer’s structured feedback (ISSUES + SUGGESTIONS) enables the 14B Planner to improve plans from 0.10–0.20 to 0.80–0.85, while the larger 27B Planner often achieves acceptable quality on the first round.

Model	Params	Translate	Execute
phi4-mini	3.8B	98.2%	70.6%
		(109/111)	(77/109)
functiongemma	270M	54.0%	25.9%
		(27/50)	(7/27)
ministral-3	14B	100%	20.0%
		(40/40)	(8/40)

Table 10: Tool model reliability comparison. Translation success = valid JSON output; Execution success = correct tool result.

Scenario	Status	Score	Time (s)	Rounds	Tool Calls	Skill Learned	Notes
Shell command	PASS	9	139.6	1	5	✓	CLI execution via Executor
PDF processing	PASS	9	152.2	2	7	✓	Multi-step: extract + summarize
Travel planning	FAIL	0	309.8	1	1	—	No network in test environment
MCU comparison	PASS	7	172.0	1	3	—	Web search + analysis
WeChat messaging	PASS	9	81.8	1	5	✓	Innate skill + GUI automation
Story creation	PASS	8	321.4	1	7	✓	Generative task; file_write used

Table 11: Multi-scenario diagnostic test results. Five of six scenarios pass (83.3%). The travel planning failure is due to the test environment lacking network access. Skill learning is triggered automatically for tasks rated

\geq 7

System	Primary positioning	Local	Multi-entry	MCP	Representative characteristics
IronEngine	Desktop workbench + general assistant engine	S	S	S	Plan–Review–Execute pipeline, unified UI/API, task scheduling, hierarchical memory, skill learning, 24 tool categories, VRAM management, orchestration observability
OpenClaw	Personal AI assistant + always-on gateway	S	S	M	Multi-channel messaging (Telegram, WhatsApp, SMS), device node management, persistent skills, gateway routing
NanoClaw	Edge/IoT lightweight assistant	S	M	W	Aggressive quantization, stripped skill set, upstream proxy, Raspberry Pi deployment
IronClaw	Hardware-oriented AI agent	M	W	W	Sensor ingestion, actuator commands, safety interlocks, embedded systems integration
ChatGPT	Cloud conversational AI	W	M	W	Strong conversation, web browsing, code interpreter; cloud-dependent, no local models
Claude Desktop	Protocol-extensible assistant	M	M	S	Strong MCP integration; limited local model, scheduling, and memory support

Table 12: System-positioning comparison with representative AI agent frameworks and products

LLM Agent Orchestration

Large language model agent orchestration coordinates models, tools, and workflows to complete complex tasks reliably and efficiently.

See all 458 papers

Mar 2, 2026

ASTRA-bench: Evaluating Tool-Use Agent Reasoning and Action Planning with Personal User Context

Next-generation AI must manage vast personal data, diverse tools, and multi-step reasoning, yet most benchmarks remain context-free and single-turn. We present ASTRA-bench (Assistant Skills in Tool-use, Reasoning & Action-planning), a benchmark that uniquely unifies time-evolving personal context with an interactive toolbox and complex user intents. Our event-driven pipeline generates 2,413 scenarios across four protagonists, grounded in longitudinal life events and annotated by referential, functional, and informational complexity. Evaluation of state-of-the-art models (e.g., Claude-4.5-Opus, DeepSeek-V3.2) reveals significant performance degradation under high-complexity conditions, with argument generation emerging as the primary bottleneck. These findings expose critical limitations in current agents' ability to ground reasoning within messy personal context and orchestrate reliable multi-step plans. We release ASTRA-bench with a full execution environment and evaluation scripts to provide a diagnostic testbed for developing truly context-aware AI assistants.

Zidi Xiu, David Q. Sun, Kevin Cheng +9

Apple

Tool-Use Evaluation AI Agent Benchmarks LLM Agent Planning Personal AI Agents LLM Context Management

Ask PDF

Sep 1, 2026

Harness Engineering in LLM Tool Use via Agent-Native Reusable Tool Primitives

Large language models (LLMs) augmented with external tools have demonstrated remarkable capability in solving complex real-world tasks. However, existing approaches suffer from two key challenges: brittle multi-step and multi-turn reasoning caused by incompatible tool output types and API schemas, and performance degradation under large tool catalogues. To address these, we introduce Tool Primitives, a design that replaces rigid API schema-based invocation with natural language as the interface for tool calling, where each tool is wrapped with an LLM interface that handles schema resolution and execution internally, enabling natural inter-tool communication for nested and multi-turn tool calling. Building on Tool Primitives, we host ToolFace, a centralized repository of 25,519 functions from which LLMs dynamically retrieve only the relevant tools at inference time, eliminating the need to enumerate raw API schemas in context. To orchestrate Tool Primitives and ToolFace reliably in complex settings, we further propose HEART, a Harness Engineering framework via Agent-native, Reusable Tool Primitives, comprising a Planner, Router, and Verifier that jointly support dynamic tool invocation planning, multi-step execution, and feedback-driven recovery. Experiments on five benchmarks demonstrate that HEART outperforms SFT-based models by

10\%

on average and surpasses GPT-5.4, Claude-4.6-Sonnet, and Gemini-3.1-Pro by

6\%

on average while reducing API cost by up to

85\%

. On 50 real-world tasks, HEART achieves

84\%

task completion,

3.8\times

the average of three frontier commercial models (

22\%

Haibo Jin, Suijin Wang, Xucheng Yu +2

School of Information Sciences University of Illinois at Urbana-Champaign Champaign, IL 61820 · Independent Researcher Starc Institute

Tool-Augmented Language Model Agents LLM Agent Orchestration LLM Tool Use Tool-Using Language Agents LLM Agent Harnesses

Ask PDF

Oct 26, 2026

EREBOTS 4.0: A framework for conversational assistants with A2A agents and MCP tools

In recent years, multi-agent systems have shifted from rule-based, symbolic agents to sub-symbolic agents built on language models. However, several limitations remain unresolved. The new frontier is neuro-symbolic agents, which pair language models with deterministic tools and explicit protocols. Without a common framework to standardize and compose them, each study rebuilds the same infrastructure, and results are hard to replicate. This paper presents EREBOTS 4.0, an open-source, hybrid-AI, multi-agent framework that fills this gap for conversational assistants. Language-model agents plan and route requests, while deterministic tools compute exact results over the Model Context Protocol (MCP). An orchestrator selects one or more specialist agents per turn and calls them over the Agent2Agent protocol (A2A). A new agent, local or remote, is added by listing its URL in a configuration file. The framework also manages identity, user context with consent flags, task states and traces. Its A2A server passed 97 tracked requirements in the official A2A Technology Compatibility Kit, with no failures.

Elia Pacioni, Davide Calvaresi, Andrei C. Coman +4

HES-SO Valais-Wallis, Rue de Technopôle 10, 3960 Sierre, Switzerland · University of Extremadura, 06800, Mérida, Spain

Multi-Agent LLM Systems LLM Agents LLM Agent Orchestration Conversational Agents Tool-Using Agents Neuro-Symbolic AI

Ask PDF

Abstract

LLM Agent Orchestration

Explore similar work

ASTRA-bench: Evaluating Tool-Use Agent Reasoning and Action Planning with Personal User Context

Harness Engineering in LLM Tool Use via Agent-Native Reusable Tool Primitives

EREBOTS 4.0: A framework for conversational assistants with A2A agents and MCP tools