systems engineering is integrations.
and integrations have been growing in complexity for forty years. every new capability arrives as its own product category, with its own semantics, its own operational model, and its own integration tax against everything already in your stack. we believe this pattern is ending. a paradigm shift is here, and we are building for it.
three primitives are enough.
worker. trigger. function. a worker is any process that joins the system. a trigger is anything that causes work to run. a function is the unit of work. every capability (queues, cron, streaming, sandboxing, observability, agents, business logic, devices, UIs, and everything not yet imagined) is built from these three things. the primitives are small enough to hold in your head. everything else is a property of the engine, or a worker someone published.
paradigms win by collapsing categories.
unix won on everything is a file. react won on everything is a component. http won on request and response. every paradigm that compounded for decades did so because the primitive was small enough to fit in your head. iii makes that bet for the entire software stack.
have a need? add a worker.
need a queue? add a worker. need real-time streaming, scheduling, sandboxing, observability, an agent, a CRM integration, a browser tab as a first-class participant? add a worker. some workers are deterministic code. some are stochastic agents. most real systems are a mix. the semantics live in the functions, not in the category.
quadratic to linear.
four services means six possible integrations. twenty means 190. each new addition compounds the coordination cost of everything that came before. iii ends this. a new worker joins by opening a single connection. adding four workers, or twenty, takes the same effort: zero. each worker is immediately available to every other worker the moment it registers. the architecture stops paying compound interest on complexity.
same contract, both sides of the house.
application teams register functions and declare triggers, focused entirely on business logic. platform teams publish workers, focused entirely on the capabilities they provide. both sides fulfill the exact same contract. no bespoke SDKs. no internal client libraries. no per-service API contracts. no integration consulting. the work that used to live between teams disappears.
live by default.
when a worker registers, its functions become visible and callable across the entire system in real time. when it unregisters, they are gone. traces span every worker, across every language, across every process. the engine is the registry. the protocol is the wire. observability is the wire protocol. there are no stale specs, no propagation delays, and no disconnected log streams to grep across.
any language. any runtime. one system.
a typescript worker calls a python worker the same way it calls another typescript worker. the engine handles serialization and routing. a worker in docker, on kubernetes, on the edge, in a browser tab, on a raspberry pi, or inside a hardware-isolated microVM is the same kind of worker. moving a workload is a redeploy, not a rewrite.
humans and agents share one mental model.
a new engineer is productive on day one because their mental model never changes from one capability to the next. ai agents can reliably reason about an entire system in a single context window because there is one set of primitives to learn and one always-accurate source of truth for what exists. as agents do more of the work of building and operating software, small primitives compound: easier to onboard, cheaper to prompt, faster to extend, simpler to maintain.
agents are workers.
an agent's tools are functions. its memory is state. its orchestration is triggers. the harness is the system. an agent that hits a task outside its current capabilities can register a worker at runtime and use its functions immediately. this is the difference between scripted LLM calls and real autonomy.
iii worker add is the npm moment for systems.
what you install is not a library. it is a running participant. a queue worker. a sandbox worker. a classifier. a CRM integration. one command, complete capability, immediately available to every other worker in the system. capabilities that used to require vendor evaluation, procurement, and integration become a single line.
add a worker. add a worker. add a worker.
AI is the forcing function. simplicity beats complexity. the category-shopping era of software engineering (evaluate, procure, integrate, repeat) is ending. what replaces it is one protocol, three primitives, and a registry of workers that compose without coordination. anything can participate. everything composes. software becomes unreasonably simple to create, extend, and modify.