We have been exploring ways to coordinate AI agents and services cleanly, observably, and without turning everything into YAML spaghetti.
We came across this repo Happen, how good will it be cause we have We’ve tried the usual stuff:
LangChain (too bloated, too magic)
Autogen (chat loop hell)
CrewAI (fun, but brittle when workflows grow)
https://github.com/RobAntunes/Happen/tree/main/examples
Will have to look deeper into this later, but on a superficial level, this seems a lot like OOP with extra steps, those being cryptographical verification of each node("objects") and making polymorphism/type erasure implicit(instead of passing an interface to a constructor which then gets used by the object, the object just shouts events into the void hoping someone will answer). Also it's stringly typed because this is JavaScript, and it's triggering flashbacks of misspelling field/function names and wondering why everything breaks.
Will have to look deeper into this later, but on a superficial level, this seems a lot like OOP with extra steps, those being cryptographical verification of each node("objects") and making polymorphism/type erasure implicit(instead of passing an interface to a constructor which then gets used by the object, the object just shouts events into the void hoping someone will answer). Also it's stringly typed because this…
Hey, builder here, appreciate your reply don't normally put our stuff out there so it's a bit of an adventure in an of itself.
Totally get where you're coming from with the OOP comparison!
The node/event pattern does look familiar on the surface, but instead of objects calling each other's methods directly, components just put information out there and continue with their work. the system maintains causality while remaining completely asynchronous.
"Shouting into the void" that's a great visual We do have 3 communication patterns though - req/res, pub/sub, and indeed shouting into the void.
On the stringly typed thing - yep, I feel you! We're definitely going to strongly type the framework as we move forward we just wanted to get something out there to get some feedback.
What really makes Happen different is how it uses causality as its organizing principle. The verification stuff isn't just extra complexity - it creates a trail of breadcrumbs that proves where events came from and how they relate to each other. This lets you build distributed systems that don't need complex consensus protocols to trust each other.
We also noticed that there are already great projects out there for agentic applications but getting them all to work together is difficult. Ultimately Happen is our attempt at solving for our use case, connecting ready made systems together in the simplest, most powerful way possible.
Would love to hear what you think after you've had a chance to dig deeper! The OOP comparison is actually a great starting point for understanding the differences.
Will have to look deeper into this later, but on a superficial level, this seems a lot like OOP with extra steps, those being cryptographical verification of each node("objects") and making polymorphism/type erasure implicit(instead of passing an interface to a constructor which then gets used by the object, the object just shouts events into the void hoping someone will answer). Also it's stringly typed because this…
Hey, builder here, appreciate your reply don't normally put our stuff out there so it's a bit of an adventure in an of itself. Totally get where you're coming from with the OOP comparison! The node/event pattern does look familiar on the surface, but instead of objects calling each other's methods directly, components just put information out there and continue with their work. the system maintains causality while re…