Mike's Notes
The work this week.
I found a problem with the existing Pipi 6 era Messaging Engine (msg). It needed to be replaced to support the richer Pipi 9 internal environment of autonomous agents that can self-organise and move.
I spent days staring into space, and then the solution became very clear while daydreaming 😴 between morning coffee and ice cream summer afternoons 😎. Slow but getting there.
Resources
- https://www.hillside.net/home/mission-statement
- https://www.enterpriseintegrationpatterns.com/ramblings/94_37things.html
- https://www.amazon.com/o/asin/073561850X/
- https://www.enterpriseintegrationpatterns.com/books1.html
- https://www.enterpriseintegrationpatterns.com/patterns/messaging/ComposedMessagingExample.html
- https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageRoutingIntro.html
- https://en.wikipedia.org/wiki/Enterprise_Integration_Patterns
- https://ieeexplore.ieee.org/document/7368007/
- https://online.visual-paradigm.com/diagrams/templates/enterprise-integration-patterns/
- https://www.enterpriseintegrationpatterns.com/downloads.html
- https://wiki.ajabbi.com/eng/9/primative-engine.html
- https://www.blog.ajabbi.com/2025/11/pipi-engines-to-build-deploy-and-manage.html
References
- Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions (Addison-Wesley Signature Series), by Gregor Hohpe and Bobby Woolf.
- Integration Patterns (Patterns & Practices). Microsoft.
Repository
- Home > Ajabbi Research > Library > Authors > Gregor Hophe
- Home > Handbook >
Last Updated
25/01/2026
Recent work on system messaging
Mike is the inventor and architect of Pipi and the founder of Ajabbi.
Pipi 4 (2005-2008)
A simple internal messaging system was invented and built for Pipi 4 around 2005. It had a messaging store and handled interactions between different internal systems. It was not called a messaging system; it was an unnamed part of the Metadata Repository. It was built in CFML code and ran on MS SQL Server.
Pipi 6 (2017-2019)
After reading about Apache Kafka and RabbitMQ, I realised that Pipi 4 had contained a primitive internal messaging system, 5 years before Kafka. A new, quick-and-dirty broker-based messaging system, similar to RabbitMQ, was built as a CFML module to send messages across hundreds of modules when Pipi 4 was rebuilt from memory as Pipi 6. The work of Gregor Hohpe and Bobby Woolf was an inspiration. Martin Fowler was an enormous influence on everything.
Pipi 9 (2023-
It has taken all week to figure out a solution. I ended up splitting the role of the engine
- The existing Pipi 6 messaging module is now being fully refactored into the Pipi 9 Messaging Engine (msg). Previously, it used a wrapper to make it appear to be an agent. Some minor changes are being made to the Namespace Engine (nsp).
- The new Messaging Engine (msg) is used to create the local messaging systems via the Factory Engine (fac). The Factory Engine (fac) will place a local message store using a separate embedded database inside each agent to connect to its Messaging Endpoint. Each system (made up of many agents) has its own messaging store attached to the system router.
As agents dynamically self-assemble in response to events, the messaging system always works.
The new Engine closely follows the patterns in Enterprise Integration Patterns and even uses the same icons, aka "Gregorgrams".
Summary of changes underway
- Internal system messaging between hundreds of autonomous agents.
- Possible because of the Namespace Engine (nsp) built into Pipi 8.
- External messaging between Pipi and applications, such as databases, cloud platforms and containers, will be handled using an open-source messaging system, such as Kafka or RabbitMQ.
- The two messaging systems need to interconnect. I don't know how yet! 😇
- Event messaging and Pub/Sub are the most common; others include CQRS, Dead Letter, and Point-to-Point.
- Each agent has a state.
- Essential for robust Pipi self-management.
- The pipiWiki will automatically document the configuration of each engine, including messaging (Gregorgrams) diagrams. See link to the Primative Engine (prm) mockup above.
- The messaging configuration can change dynamically.
- The Messaging Engine will be accessible for configuration via the coming msg module in the Agent Workspace.
