If you're reading this article then you may be using Motia or interested in checking out what it offers. Today, we're officially setting on a path to make it much more powerful.
When we first began building Motia a year ago, we set out to answer a question: why is backend engineering still this fragmented? APIs live in one framework. State in another. Queues, cron, streaming, AI agents, and every integration each have their own runtimes, configs, and ways of failing. Developers spend as much time integrating these components with each other as they do building the thing they actually care about.
Motia was our first answer and dealt with this difficulty at the framework level. But the deeper we went, the more we realized the real problem is that there’s no way to unify all of these execution patterns into a single framework.
So we built something that could.
It's called iii (pronounced "three eye"), the Interoperable Invocation Interface. And it turns all of the existing backend complexity into something unreasonably simple: Functions, Triggers, and Workers. These three primitives enable iii to achieve something unprecedented in backend architecture:
a distributed backend that end-to-end as a single, coherent application
The result is errors that are traceable end-to-end, durable fault-tolerant execution, and functionality that can be added or removed without disruption. This shifts the fundamental focus of backend development away from architecture and toward functionality. A model so simple that both humans and AI agents can reason about it without running out of context.
WTF are Workers, Triggers, and Functions?
If you've been using Motia, you already know these concepts. In fact Motia compiles down to them; you've just been using these concepts under different names.
Functions are anything that does work. They also run anywhere: locally, cloud, serverless, even HTTP endpoints. From iii's perspective they're all the same thing. If you've written a Step handler in Motia, you've written a Function.
Triggers are anything that can cause a Function to run. HTTP requests, cron, queues, state changes are examples of Triggers. The event subscriptions and API routes you've been defining in Motia? Those are Triggers.
Workers are the processes that dynamically register and deregister their Functions and Triggers with iii. When you run Motia today, you're already running a Worker.
In other words: the patterns you've been building with in Motia map directly to Workers, Triggers, and Functions. Motia's model was always heading in this direction, and iii has made it explicit and universal.
What this means for Motia
Motia is now deprecated.
If you've been building with Motia, the good news is you're already most of the way there.
If you already have your backend workflows in production, you don't need to start from scratch. The concepts you're using today: Steps, routes, subscriptions map cleanly onto iii's Functions, Triggers, and Workers, and we've published a step‑by‑step migration guide to walk existing Motia projects onto iii with minimal friction.
There may be some shifts and disruptions along the way, but once the dust settles, the performance and capabilities will be far beyond the original version: truly achieving Motia's vision of making every part of the backend easily composable.
To explore iii itself, start here: https://iii.dev/docs/
To migrate your existing Motia project, the full migration guide is here: https://iii.dev/docs/migrating-from-motia
If you have questions, comment below, or need a hand with the transition, the team is available on Discord
We're just getting started with what iii makes possible. Thanks for being part of this community from the early days.
