Software engineering is an exercise in assembling categories of services.
Every new capability means a new system to learn, configure, deploy, and monitor. The complexity of actual integrations is quadratic — overwhelming for devs and for AI context.
iii fundamentally eliminates this complexity and makes
it linear.
And we ship integrations the same way node ships packages so
using a new service is as easy as importing a new library.
import { registerWorker, Logger } from "iii-sdk"
const iii = registerWorker(
"ws://localhost:49134"
)
const logger = new Logger()
const nums = await iii.trigger({
function_id: "data::transform",
payload: [1.0, 2.0, 3.0],
}) // → [2.0, 4.0, 6.0]
const pred = await iii.trigger({
function_id: "ml::predict",
payload: { data: nums },
}) // → { predictions: […] }
logger.info(pred) // ml::predict → { predictions: [0.91, 0.07, 0.02] }use iii_sdk::{
register_worker, IIIError,
Value,
};
use serde_json::json;
async fn transform(
input: Value,
) -> Result<Value, IIIError> {
let nums: Vec<f64> =
serde_json::from_value(input)?;
let result: Vec<f64> =
nums.iter().map(|x| x * 2.0).collect();
Ok(json!(result))
}
#[tokio::main]
async fn main() -> Result<(), IIIError> {
let iii = register_worker(
"ws://localhost:49134",
InitOptions::default(),
)?;
iii.register_function(
"data::transform",
transform,
);
Ok(())
}import torch
from iii import register_worker
iii = register_worker("ws://localhost:49134")
async def predict(input):
t = torch.tensor(input["data"])
result = model(t)
return {
"predictions": result.tolist()
}
iii.register_function(
"ml::predict", predict
)every worker — across runtimes — discovered as it connects.
every function — every language — invokable from one place.
http, events, cron, websockets — every entrypoint, one schema.
durable state — namespaced, typed, observable.
live websocket bus — agent tokens, tool calls, status, in real time.
named queues — backpressure & retries, native to the protocol.
opentelemetry, native — every span across every language, one trace.
structured logs — protocol-native, severity-coded, trace-linked.
the system at a glance — every primitive, healthy and addressable.
coordinate long-running, failure-tolerant execution across workers and triggers.
execute across languages natively, as if it were one runtime.
collapse distributed backend design into a paradigm humans and agents can reason about.
functions and triggers exposed by one worker become visible across the system in real time.
add new workers and capabilities to a live iii system without redesigning the architecture.
observe operations, traces, and behavior across the entire connected stack in real time.