Modern software stacks are an exercise in integrating services.
Every new capability means a new system to learn, configure, deploy, and monitor.
The complexity of actual integrations is quadratic which is overwhelming for devs and for AI. Leading to both making bad decisions about large codebases.
iii eliminates this complexity by shipping working services the same way node ships packages, so using a new service is as easy as importing a new library.
“Read https://iii.dev/llms.txt and https://iii.dev/AGENTS.md…”
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
)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.