iii-engine is an open-source service composition framework written in TypeScript and Rust that provides foundational infrastructure for building distributed agent systems. The framework has accumulated over 15,000 GitHub stars and serves as the underlying runtime for agent memory systems and related applications. iii-engine abstracts core primitives needed for agent orchestration, including function composition, state management, event streaming, and observability infrastructure.
iii-engine operates as a polyglot runtime environment that combines TypeScript for high-level service orchestration with Rust for performance-critical components. The framework provides several key abstractions that enable building complex agent systems: function composition for defining service workflows, key-value state storage for maintaining agent memory and context, stream processing for handling continuous data flows, and OpenTelemetry (OTEL) tracing integration for observability across distributed components 1)
The framework emphasizes composability as a core design principle, allowing developers to build complex agent behaviors by combining simpler, reusable services. This modular approach facilitates testing, debugging, and iterative development of multi-step agent workflows that may span multiple services or runtime environments.
The framework provides function composition mechanisms that enable declaring service dependencies and orchestrating execution across multiple components. These functions can be invoked sequentially, in parallel, or conditionally based on runtime state, supporting both synchronous and asynchronous execution patterns.
State management through KV (key-value) primitives allows agents to maintain persistent or ephemeral data across service invocations. This state layer is critical for implementing agent memory systems where long-term context, learned patterns, or previous interaction history must be preserved and retrieved efficiently.
Stream processing capabilities enable agents to handle continuous data flows, process real-time events, and implement reactive patterns where service behavior responds to incoming data rather than explicit requests. Streams integrate naturally with the function composition model, allowing stream data to flow through service pipelines.
OpenTelemetry integration provides standardized instrumentation for observability, enabling tracing of execution flows, performance profiling, and debugging of distributed agent systems. This observability layer captures function execution times, state transitions, and service interactions in a vendor-neutral format compatible with various monitoring backends.
Version 0.11.2 represents a stable snapshot pinned for compatibility with agentmemory implementations, as this version provides proven stability for agent memory use cases. The framework evolved toward version 0.11.6 and later releases, which introduced architectural changes including a sandbox-per-worker execution model. This architectural shift provides improved isolation and resource management but requires refactoring existing service compositions to align with the new model 2)
Organizations using iii-engine for agent memory systems must account for this versioning landscape when planning upgrades or migrations, as moving beyond 0.11.2 requires adapting service definitions to the sandbox-per-worker architecture.
iii-engine serves as the foundational layer for agent memory implementations, providing the runtime environment where agent logic executes, state persists, and observability occurs. The framework's primitives naturally support agent patterns where services maintain context across multiple interactions, learn from past experiences, and compose complex behaviors from simpler capabilities.
The combination of TypeScript and Rust enables balancing development velocity with runtime performance. Service logic can be rapidly prototyped in TypeScript while performance-sensitive components leverage Rust's efficiency, and both languages can coexist within the same service composition framework. This polyglot approach reduces pressure to optimize prematurely while maintaining capacity for targeted performance improvements where needed.