Restate Blog

Hi! I'm building Soma. Soma is a platform where you can write & deploy AI agents or AI enabled workflows as code. Think n8n but without the messy visual notation, just regular code. We provide a single pane of glass to view, observe and monitor all your agents. And I'm looking for feedback ( http://trysoma.ai/ , old clickable prototype for the management UI https://wireframe.trysoma.ai/ ). 4 things that really stand out from our platform vs others: 1. We let you link multiple agents to a single inbox (Gmail, Slack etc.), and we intelligently route messages to a sub-agent you've deployed. Your end users see one agent (i.e. customer service agent, internal employee assistant or company book-keeper) and have a single unified entry point and UX for all linked workflows. Our in-house LLM routes requests or asks follow up questions until it knows what you want to do. 2.You can A/B test each deployments of the same agent. You can link custom metrics & dimensions to. So when you deploy an update to your customer refund agent, you can push custom data from Stripe or your customer satisfaction survey back into the platform and compare metrics between deployments over time. 3. It's regular code, with a few helper functions. Our SDK is based on https://restate.dev/ . TLDR; you can pause execution, replay failed workflows, and provide human-in-the-loop approval processes without custom business notations or DSLs. We've sprinkled some functionality on top of restate to enable common…

Agreed. Right now, if I needed "workflow" for a greenfield that could tolerate some risk, I'd look at https://www.restate.dev/ which matches your model of a self contained binary.

Also check out https://www.restate.dev/. We chose this internally after evaluating it against temporal, hatchet, and dbos. The docs are pretty good and development locally and deployment to k8s was simple.

My sentiments exactly - well said. The big mistake is forcing OOP onto everything. It's why I really have an affinity with the virtual actor, it has just enough OOP for me to have classes, methods and internal state - I don't need inheritance, polymorphism, etc - just naive little classifications of things we call objects. I also don't have to think of my system in a hierarchical supervised manner like earlier actor models. I just need cloud native distributed little objects. You can see some modern products coming out that are just that: 1. Cloudflare Durable Objects - https://developers.cloudflare.com/durable-objects/ 2. Restate Virtual Objects - https://restate.dev/

This is also a good use case for durable execution, see eg https://restate.dev

A few links worth sharing here: - Blog post with an overview of Restate 1.0: https://restate.dev/blog/announcing-restate-1.0-restate-cloud-and-our-… - Restate docs: https://docs.restate.dev/ - Discord, for anyone who wants to chat interactively: https://discord.com/invite/skW3AZ6uGd

It's also similar to https://www.restate.dev/.

While this does talk about durable queues, this post really hinges on a pivot to evangelizing durable workflows. It makes it sound like they're synonymous, when they're very much not. Specifically, this sentence bringing up workflows for the first time (emphasis mine): > "Durable queues were rare when I was at Reddit, but they’re more and more popular now. Essentially, they work by combining task queues with durable workflows, helping you reliably orchestrate workflows of many parallel tasks." That makes it sound like task queues + durable workflows = durable queues, but that's not true at all. A durable queue is literally a queue that doesn't drop messages e.g. during an unexpected shutdown. That's all. Durable workflows are a pretty different thing. A durable queue could be used just like a normal queue, but while you can't build a durable workflow on a normal queue (or at least, it would be a huge pain), a durable queue makes it vastly simpler to build a durable workflow engine. I think the article talks about durable workflows because this is DBOS, a company looking to sell durable workflow services, but also because durable workflows are considered by many to be a kind of "holy grail" of big-business applications as they seem like they can allow for you to write code that's kind of "always running", where the state in memory is persisted to a DB invisibly so that you have to think less about CRUD. The killer app of durable workflows seems to me to writing…

Time independence begs the question of failure recovery (and the associated at least once and at most once recovery basic options). This kind of problem is more suited to solutions like 'closure-persisted lambda functions'. Flink's Statefun comes to mind [1], and also Restate [2]. These come with their host of problems, though. For example I hope you have a strategy for distributedly tracing these, as debugging an isolated continuation will have to be done.. in isolation. Also comes the general question of lifetimes. What's GC when your functions are spread over a few kB in 100k different places in RAM, SSD, tape? Or do you go à la Rust, trying to come up with guarantees of them (and recover at least once these?) Of course Loom's continuation can have a play in this, maybe be the underlying efficient serde mechanism? There are initiatives to freeze whole JVMs, and bring them back in RAM when there's an HTTP call to be answered for example [3]. Maybe the path of performance for these is in only thawing the continuations and their dependencies, and blocking on >1h delays means getting frozen to the SSD. Maybe in the future AWS is going to bill webserver lambda usage with SSD IOPS and RAM-L3-L2-L1 occupancy granularity. Like Feynman said, there's plenty of (design) space at the bottom. [1] https://nightlies.apache.org/flink/flink-statefun-docs-stable/ [2] https://www.restate.dev/ [3]…

They mention it in their about page: https://restate.dev/about

Reminded me of the Restate idea[1], discussed here[2] recently, except they do it as a library. An excerpt: To persist intermediate steps (line 8), handlers use the SDK (ctx.run), which sends the event to the log and awaits the ack of the conditional append to the event’s execution journal. On retries, the SDK checks the journal whether the step’s event already exists and restores the result from there directly. Though I think I agree with your point that it would be better to have this even more integrated than "just" a library. Perhaps something like how you can override the global memory allocator in C and similar languages, to avoid a tight coupling to the persistence layer. [1]: https://restate.dev/blog/every-system-is-a-log-avoiding-coordination-i… [2]: https://news.ycombinator.com/item?id=42813049

relatedly: https://restate.dev/blog/every-system-is-a-log-avoiding-coordination-i… https://news.ycombinator.com/item?id=42813049

I hope @sewen will expand on this but from the blog post he wrote to announce Restate to the world back in August '23: > Stateful Functions (in Apache Flink): Our thoughts started a while back, and our early experiments created StateFun. These thoughts and ideas then grew to be much much more now, resulting in Restate. Of course, you can still recognize some of the StateFun roots in Restate. The full post is at: https://restate.dev/blog/why-we-built-restate/