iii-hq/iii
Iii
iii is a distributed service orchestrator and event-driven workflow engine designed to compose and manage cross-language functions and workers through a central execution engine. It functions as a multi-language service mesh and WebSocket service gateway, providing a persistent communication layer for remote service workers.
The platform enables dynamic runtime extensions, allowing new workers and capabilities to be deployed and registered into a live environment without requiring system restarts. It distinguishes itself by offering machine-readable skill exposure and agent capability integration, allowing AI agents to discover and utilize system functions.
The system covers a broad range of capabilities, including durable service orchestration for long-running processes, declarative event routing for mapping triggers like HTTP endpoints and cron schedules to logic, and real-time observability via W3C trace propagation. It further provides bidirectional binary data streaming, role-based access control, and cross-architecture binary compilation for cloud deployment.
The project provides standardized client libraries for Node.js, Python, and Rust to connect services to the core engine.
Features
- Distributed Worker Orchestration - Coordinates the execution of independent workers and functions across languages to build durable service workflows.
- Agent Capability Extensions - Publishes machine-readable skills and functions so AI agents can discover and utilize system operations.
- Event-Driven Workflows - Maps HTTP endpoints, cron schedules, and queues to executable logic in real time.
- Declarative Event Routing - Maps diverse triggers like HTTP endpoints and stream events to specific functions to automate data delivery.
- Event Triggers - Links external events like HTTP requests or cron schedules to named handler functions for automated execution.
- Service Meshes - An interoperable layer for invoking remote functions across Node.js, Python, and Rust using standardized SDKs.
- WebSocket Services - Provides a persistent communication layer with bidirectional data streams and automatic reconnection for remote workers.
- Cross-Language Execution Layers - Provides a unified execution layer that enables functions written in different languages to run seamlessly.
- Live Service Worker Registration - Adds new capabilities and service workers to a live system without requiring a restart or redeployment.
- Language Interoperability - Enables interoperable execution of logic across different programming languages via a unified execution layer.
- Distributed Service Composition - Coordinates behavior across multiple service workers by mapping functions to triggers like HTTP endpoints or schedules.
- Durable Workflow Engines - Provides a platform for building long-running, fault-tolerant business processes that persist state across infrastructure failures.
- Durable Workflow Execution Engines - Ensures long-running processes and service workflows complete reliably across a distributed system.
- Event-Driven Architectures - Builds reactive systems by linking HTTP endpoints and cron schedules to specific executable functions.
- Function Execution Engines - Provides a central engine responsible for routing and executing discrete named handler functions.
- Hot-Pluggable Runtime Extensions - Allows new workers and capabilities to be deployed into a live environment without requiring system restarts.
- Runtime Capability Extensions - Enables deploying and registering new workers and capabilities into a live environment without requiring system restarts.
- Named Function Registries - Enables linking unique identifiers to handler functions so business logic can be invoked by name.
- Real-Time Service Orchestration - Builds a network of observable services using a high-performance engine to coordinate real-time data and logic.
- Remote Function Invocation - Triggers registered functions with payloads using synchronous awaiting, fire-and-forget patterns, or queue-based routing.
- Hot-Loading Workers - Enables the deployment of new capabilities and workers into a live environment without requiring system restarts.
- Machine-Readable Capability Exposure - Publishes reference material for primitives and worker capabilities so agents can discover and utilize system functions.
- Distributed Worker Inspection - Inspects workers, functions, triggers, and logs through a centralized console to monitor service behavior.
- Cloud Deployment - Handles the full lifecycle of remote deployments by creating, updating, and deleting service instances in cloud environments.
- Remote Worker Execution - Manages the invocation and handling of remote workers using queues and custom triggers.
- Bidirectional Streaming Protocols - Opens dedicated sockets that separate raw binary streams from text messages for high-volume data transfer.
- Connection Management Strategies - Maintains a persistent link to the core engine using exponential backoff reconnection and an offline buffer.
- Websocket Connection Managers - Implements persistent WebSocket connections with automatic reconnection and telemetry tracking for engine connectivity.
- Distributed Trace Propagation - Carries W3C trace headers across service boundaries to maintain observability in distributed systems.
- Tracing Context Propagation - Carries W3C trace headers across service hops to maintain observability and distributed request tracking.
- Cross-Platform Binary Generation - Builds release binaries targeting different CPU architectures and operating systems to ensure hardware compatibility.
- Service Primitive Composition - Builds complex features like queues and cron jobs by combining standardized worker, trigger, and function primitives.
- Multi-Language SDKs - Ships standardized client libraries for Node.js, Python, and Rust to connect services to the engine.
- Distributed Observability Platforms - Tracks distributed service behavior and state through W3C trace propagation and live telemetry.
- Real-Time Monitoring Systems - Monitors the internal state and performance of distributed services with live traces and execution tracking.
- Service Discovery - Identifies and locates available functions and services within a running system in real-time.
- Service Discovery & Observability - Tracks the internal state and performance of running services to provide real-time visibility into execution.
- Asynchronous Programming - Distributed runtime for composing services via worker primitives.
- 开发者工具 - Distributed runtime for composing services via worker functions.
