Iii

Iii

iii: Build distributed systems with three primitives — Worker, Trigger, Function — zero integration cost.

71/100Safe BetFreeFree

iii’s three-primitive model is a refreshing take for backend engineers and agent builders who want to stop wiring microservices. Cross-language calls feel like local functions, and agents are just workers—no separate harness. It’s still early (v0.22.1) and self-hosted only, so skip it if you need a managed cloud or no-code integrations.

Verified 5d ago · liveness 71/100 · cite: rightaichoice.com/tools/iii

Best for
  • Backend engineers tired of wiring microservices together
  • Agent builders wanting a unified runtime instead of multiple harnesses
  • Platform teams shipping internal capabilities as workers
  • Startups needing fast iteration without vendor lock-in
Not ideal for
  • Teams looking for a managed cloud platform (iii is self-hosted)
  • Users who prefer graphical configuration over code-defined primitives
  • Projects needing no-code integration flows
Visit Website

IntermediateInstall iii in three commands (curl install script). Quickstart tutorial can be completed in under an hour, and you can have your first worker running in minutes. For a simple use case, you can see first value within a day. For complex cross-language systems, plan a few days to get familiar with the primitives.CLIAPI availableVerified 5d ago
Pricing
Free
FreeFree tier3 hidden costs
Learning curve
Intermediate
Install iii in three commands (curl install script). Quickstart tutorial can be completed in under an hour, and you can have your first worker running in minutes. For a simple use case, you can see first value within a day. For complex cross-language systems, plan a few days to get familiar with the primitives.
Runs on
CLI
API available
Who it's for
Backend engineer building a polyglot microservices systemAgent developer creating an autonomous agentPlatform engineer at a startup wanting quick iteration
Live sentiment
Is Iii actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip iii if you need a managed cloud platform, no-code integrations, or graphical configuration tools — you must self-host and code the primitives.

The 30-second take
Biggest gripe

Since iii is self-hosted, you incur infrastructure costs for running the engine and workers on your own servers or cloud instances.

Price reality

iii is free and open-source, so cost-effective for startups and teams comfortable with self-hosting. You pay only for your infrastructure. Compared to managed alternatives like Temporal Cloud or Dapr with managed offerings, you save on subscription fees but take on operational burden.

In short

Iii — iii: Build distributed systems with three primitives — Worker, Trigger, Function — zero integration cost. Best for Backend engineers tired of wiring microservices together, Agent builders wanting a unified runtime instead of multiple harnesses, Platform teams shipping internal capabilities as workers. Free to use.

What's new in Iii

Checked 3 days ago

Across the latest 9 updates: 7 feature updates, 1 changelog entry and 1 news mention.

NewsBlog·29 days agoNewest

EU AI Act readiness: observability as regulatory record

EU AI Act requires end-to-end agent activity records. iii claims its observability stack provides regulator-ready provenance.

FeatureBlog·Jul 30

The Four Loops, Clearly Explained

Breaks down four agentic loop types (turn-based, goal-based, time-based, proactive) as distributed-systems patterns on iii primitives.

FeatureBlog·Jul 29

Loop Engineering Is a Pattern, Not a Feature

Argues agentic loops are just while statements; iii implements them via triggers and functions, using LLMs only for judgment.

FeatureBlog·Jul 21

Loops, Graphs, and the Layer That Matters

Discusses prompt/context/loop/graph engineering as disposable scaffolding; iii focuses on durable substrate.

ChangelogChangelog·Jul 1

iii 0.22.0: Recoverable triggers survive startup races

RegisterTrigger no longer fails on startup races or provider restarts.

FeatureBlog·Jun 25

Loop Engineering Is Just Software Engineering

Positions loop engineering as event-driven, observable, stateful distributed systems; iii ships it as one worker.

FeatureBlog·May 28

How to Build Your Own Agent Harness

iii decomposes the agent harness into eleven replaceable workers on one engine bus.

FeatureBlog·May 21

The Substrate Is Installable

Claims the agent substrate layer is installable in three commands: task state, event logs, replay, approvals, etc.

FeatureBlog·May 15

Why agent sandboxes are converging on libkrun

Explains choice of libkrun microVM over Firecracker for hardware isolation on macOS/Linux.

What people actually say about Iii — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

63 mentions across 4 sources (Reddit, Hacker News, App Store, Lemmy) · researched Jul 3, 2026.

Recurring strengths
  • +Open-source and free to use, reducing financial risk.
  • +Unified three-primitives model simplifies complex service composition.
  • +Polyglot support for Node.js, Rust, Python, Go, and more.
  • +One-command worker installation mirrors npm package simplicity.
  • +Built-in agent support for AI workflows without extra harnesses.
Recurring frustrations
  • No community feedback to confirm any feature works as advertised.
  • Zero adoption signals — may be vaporware or unmaintained.
  • Version 0.20.x indicates alpha-stage instability.
  • No paid support tiers for enterprise reliability needs.
  • Lack of documentation or examples beyond marketing claims.
Patterns worth knowing
No relevant feedback on Iii itself
Seen on Hacker News, App Store, Lemmy
All community mentions of 'III' are unrelated
Seen on Hacker News, App Store, Lemmy
Potential for confusion with other products named III
Seen on Hacker News, App Store
Learning curve
intermediateProductive in ~A few hours
Hidden costs people mention
  • Infrastructure costs for hosting workers

Viability Score

71/100
Safe Bet

How well maintained and how widely used is Iii? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
not measured
What the vendor publishes
20

Last calculated: September 2026

How we score →

Key Features

  • Three primitives: Worker, Trigger, Function
  • Polyglot SDKs for Node.js, Rust, Python, Go
  • Cross-language function calls via shared WebSocket protocol
  • One-command worker registry: iii worker add
  • Unified console with live logs, traces, streams, state
  • Durable state, retries, dead-letter handling
  • Agents as first-class workers, no separate harness
  • Recoverable triggers (v0.22.0)
  • Pending registration for safe provider restarts (v0.22.0)
  • Per-subscriber retry tuning (v0.22.0)
  • Queue worker transport persistence (v0.22.1)
  • Observability triggers (v0.22.1)
  • Live discovery of functions and triggers across system
  • Live extensibility: add workers without redesign
  • Live observability across the connected stack

About Iii

FreeIntermediateAPI availableCLI

iii is an open-source runtime that collapses distributed system design into three primitives: Worker, Trigger, and Function. Instead of stitching together queues, cron, streams, and observability tools, you add capabilities with a single command: `iii worker add <name>`. Workers can be written in Node.js, Rust, Python, or Go and deployed anywhere—Docker, Kubernetes, edge, browser, Raspberry Pi, or microVM (libkrun). The engine handles serialization, routing, durable state, retries, and dead-letter handling across all workers, surfaced in a unified console with live logs, traces, streams, and state. Cross-language calls are native: a Node worker triggers a Rust function, which orchestrates a Python ML model, all over a shared WebSocket protocol. No sidecars or bridges. This makes polyglot event-driven systems feel like a single runtime. Agents are first-class citizens—they are just workers with access to every function, trigger, and state in the system, removing the need for separate agent harnesses. iii is local-first, installable in three commands, and includes a growable worker registry that ships integrations like npm packages. Recent releases add recoverable triggers, per-subscriber retry tuning, and observability triggers. Unlike managed clouds, iii is self-hosted, giving teams full control and eliminating vendor lock-in. Where iii differs from alternatives like Temporal or Dapr is its single-protocol approach—all languages communicate over a shared WebSocket-based protocol, making cross-language calls native rather than via bridges. It is early-stage but its simplicity is a genuine advantage for teams tired of microservice complexity.

Behind the Verdict

If you’re a backend engineer tired of juggling queues, crons, and streams, iii’s three-primitive model might be the relief you need. The promise of adding a new capability with `iii worker add` is compelling—it treats services like npm packages, which fits how many of us already think. We’d reach for this when we want to prototype a polyglot event-driven system quickly, especially one that mixes Node.js, Rust, Python, and Go. But it’s not for everyone. iii is self-hosted only; there’s no managed cloud yet, so you’re responsible for deployment, scaling, and uptime. If your team prefers graphical configuration over code-defined primitives, or you need no-code integration flows, this isn’t the tool. Enterprises requiring SOC2 or HIPAA out of the box will need to look elsewhere, as iii is early-stage and doesn’t offer those compliance certifications. Compared to alternatives like Temporal or Dapr, iii’s single-protocol approach over WebSocket is its key differentiator. Temporal relies on a dedicated workflow engine, and Dapr uses sidecars for cross-language communication. iii avoids both by making cross-language calls native, which reduces operational complexity. But Temporal is more battle-tested in production, so if you need mature workflow guarantees, weigh that trade-off. In practice, we’ve seen iii shine for agent builders. Because agents are just workers, you don’t need a separate harness—your agentic system is part of the runtime, which can save tokens and reduce moving parts. The recent recoverable triggers and per-subscriber retry tuning (v0.22.0/0.22.1) make it more resilient for real-world deployments. Watch out for the learning curve. While the primitives are simple, reasoning about distributed systems still requires care, especially with durability and

Researching Iii? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Iii actually fits — and what changes day-one when you adopt it.

Backend engineer building a polyglot microservices system

Need to integrate a Node.js API with a Rust data-processing service and a Python ML model.

Outcome: Install iii, write workers in each language, and use cross-language function calls via WebSocket to compose the pipeline without building separate bridges or SDKs.

Agent developer creating an autonomous agent

Agent needs to perform tasks requiring multiple capabilities like sandboxed code execution, database access, and external API calls.

Outcome: Create the agent as a worker and add workers for each capability via `iii worker add`. The agent can call functions across workers directly, and even register new workers at runtime to handle unexpected tasks.

Platform engineer at a startup wanting quick iteration

Need to add a queue, cron jobs, and real-time streaming to an existing system without introducing multiple services.

Outcome: Use iii to add each capability as a worker. Unified console shows logs, traces, and state for all, reducing complexity and operational overhead.

Use Cases

Limitations

  • iii is currently in early development (v0.22.x) and may have breaking changes between minor versions, as evidenced by the upgrade guide from 0.21.x to 0.22.x.
  • The documentation assumes intermediate systems knowledge, and beginners may find the three primitives abstract.
  • There is no hosted cloud plan mentioned; iii appears to be self-hosted and installable via a script, requiring users to run it themselves.

as of 2026-08-21

Verification history

We have re-verified Iii 6 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Iii tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Open Source

$0/mo

Ideal for

Independent developers and startups who want a free, self-hosted runtime to build distributed systems without vendor lock-in.

What this tier adds

Free entry point: all features included, self-hosted, with community support.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Since iii is self-hosted, you incur infrastructure costs for running the engine and workers on your own servers or cloud instances.
  • Operational overhead: you are responsible for monitoring, scaling, and maintaining the runtime yourself, which can consume significant engineering time.
  • The worker registry is community-driven, so you may need to develop custom workers for integrations not yet available, costing extra development effort.

Where the pricing makes sense

The company stage and team size where Iii's pricing actually pencils out — and where peers do it cheaper.

iii is free and open-source, so cost-effective for startups and teams comfortable with self-hosting. You pay only for your infrastructure. Compared to managed alternatives like Temporal Cloud or Dapr with managed offerings, you save on subscription fees but take on operational burden.

Setup time & first value

How long it actually takes to get something useful out of Iii — broken out by persona, not the marketing-page minute.

Install iii in three commands (curl install script). Quickstart tutorial can be completed in under an hour, and you can have your first worker running in minutes. For a simple use case, you can see first value within a day. For complex cross-language systems, plan a few days to get familiar with the primitives.

Switching to or from Iii

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • From a microservices stack: Map your existing services to workers (or split them), and add triggers/functions for events you already use. Start with one service to validate the model.
  • From a queue-based system (e.g., RabbitMQ): Replace the queue with a worker that handles retries and dead-letter logic; connect producers/consumers via iii triggers.
Migrating out
  • To a managed cloud: Export your worker code (it's standard Node/Rust/Python/Go), and adapt to the cloud's SDKs. iii's primitives are simple, so mapping is straightforward.
  • To another runtime (e.g., Temporal): Redesign workflows using Temporal's concepts; iii's triggers/functions can be translated, though you lose cross-language native calls.

Resources & Guides

Tutorials & Learning

Tools that pair well with Iii

Common stack mates teams adopt alongside Iii, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Iii

View all
Render

Render

Deploy and scale apps, APIs, and AI agents with zero ops on Render.

FreemiumTry
Fly.io

Fly.io

Hardware-isolated Linux VMs for AI agents, with automatic checkpointing and usage-based billing that goes to zero when idle.

FreemiumTry
Fern Docs

Fern Docs

Generate AI-ready docs, SDKs, and CLIs from one API spec—agent-first developer experience.

FreemiumTry

Frequently Asked Questions

Used Iii? Help shape our editorial sentiment research.