The eGate generation already knows how agentic systems should run

Around 2000 I was wiring enterprise systems together with SeeBeyond's eGate, writing transformations in a tiny Scheme dialect called Monk. This week, building multi-agent orchestration into xNAUT, I kept having the same feeling: I have built this before. I had. Everyone from that era has.

28 August 2026 · André

What we were actually building back then

EAI, enterprise application integration, was the unglamorous middle of the software world. SAP on one side, a warehouse system on the other, neither willing to speak to anything. Our job was everything between: adapters, typed messages, transformation, routing, queues that guaranteed delivery even when an endpoint died mid-flow. The cloud was called the server room and it had a door. Documentation came in binders heavy enough to be a workplace hazard. We were, and I need you to sit with this, paid to write Scheme, on purpose, for banks.

The endpoints were dumb. That is the detail that matters. Every drop of judgment in an eGate flow came from a human who had encoded it in advance. So all of our engineering went into the part around the judgment: an Event Type Definition so no message without a declared shape could enter the flow, intelligent queues so nothing assigned was ever lost, compensation paths so a half-finished flow could be walked back, and monitoring on everything, because a silent integration is a broken integration that has not been discovered yet.

Harnesses. Guard-rails. Rollback. We did not call them that. They were just what you built so the flow survived contact with reality.

Then the endpoint learned to think

What changed in the last two years is exactly one component. The endpoint. The dumb adapter became a model that can read a ticket, write code, and explain itself. Everything else in an agentic system, everything, is the old middle: how work is assigned, how messages carry shape, how state survives a crash, how a bad change is walked back, who may declare a thing finished.

And here is what I keep seeing: the agent world is re-learning that middle from scratch, usually badly. Lost assignments, two agents writing over each other, "done" claims nobody verified, messages with no declared shape, no way to undo what an agent landed overnight. Every one of those is a solved problem. It was solved by people who could not fall back on the endpoint being smart, which forced the discipline into the infrastructure, which is exactly where it still belongs. A smart endpoint is not a reason to skip the discipline. It is more traffic through it.

This week we shipped a merge gate that scores risk before anything lands, kill-switches that drop a whole layer with one audited flag, typed claims where done and complete mean two enforceably different things, and a pull loop where the assignment lives in a durable record instead of in anyone's memory. As I was drawing the guard-rail map for it, the shape looking back at me was an eGate collaboration diagram. I laughed out loud.

A receipt, from the archive

I dug out some pre-historic code snippets. This is real Monk from 2002, an error path, trimmed for length only:

;;External Monk Function
;;usage:(NOC-Error-To-Queue <message-string> <eway-name> ...)
(define NOC-Error-To-Queue
  (let ((output ($make-event-map ERROR-delm ERROR-struct)))
  (lambda (message-string eway-name input-event-type output-event-type)

   (copy-strip "e*Gate error" ~output%ERROR.DataSet.ERROR.AttSet.message_desc.Value "")
   (copy-strip eway-name ~output%ERROR.DataSet.ERROR.AttSet.adapter_name.Value "")
   (copy-strip (exception-string-all) ~output%ERROR.DataSet.ERROR.AttSet.error_description.Value "")
   (copy-strip message-string ~output%ERROR...DataSet.Data[0].CDATA[0] "")
   (timestamp ~output%ERROR.DataSet.ERROR.AttSet.error_date_time.Value "%Y-%m-%d-%H-%M-%S")

   (iq-put output-event-type ($event->string output) (list input-event-type) 0 0 5)

   ($event-clear output)
)))

Yes, those are all parentheses. We counted them by hand and we were grateful for the work. Read what it does, not the parentheses. A message failed somewhere. Instead of a log line, the failure becomes a typed event with a declared shape: which adapter, what exception, when, and the original message carried whole as payload so nothing is lost. Then it goes onto a guaranteed queue, with retry arguments, where something is obliged to deal with it. The failure is data with an address, not text in a file.

That is, mechanism for mechanism, what our agent layer does in 2026 when a guard-rail refuses a merge: a typed refusal naming who, what and why, parked on a durable surface a human is obliged to see. I worked on flows like this 26 years ago, and I did not sit down this week to copy them; I could not have. What happened is that remembering bits and pieces of that world, a typed error here, a guaranteed queue there, kept answering the questions the agent work was raising. The missing part of agentic backend engineering was not waiting to be invented. It was waiting to be remembered.

The map, explicitly

Monk itself carries the deepest lesson on that list. It was fast, and it was fast because it refused to be general. A tiny language for one job, embedded where the job was. And its ending is a lesson too, in three acts, the first self-inflicted. SeeBeyond generalised itself: ICAN 5.0 rewrote the platform in Java and sidelined Monk. Sun bought the result in 2005 and renamed ICAN to JCAPS, the Java Composite Application Platform Suite. Oracle bought Sun in 2010, JCAPS came with it, and Oracle shelved it in favour of its own SOA stack, which cleared a competitor from the field. Going general killed the product before anyone bought it; acquisition just buried it. The agent frameworks accumulating abstractions right now, and the ones hoping to be acquired by the platforms they compete with, might want to sit with that for a minute.

Old skills are not dead

If you spent the 2000s in eGate, webMethods, TIBCO, BizTalk, MQSeries, any of that world, you are not behind on agents. You are ahead on the part that decides whether an agentic system survives its first bad night. You already think in flows, not calls. You already assume every endpoint will fail, because yours always did. You already know that a message without a shape is a bug that has not happened yet, and that anything landed without a compensation path is a hostage.

Add today's agent capabilities to that instinct and you understand how a future agentic system should run better than most people currently building them. The revival is not nostalgia. The patterns worked for decades in production, in industries where a lost message was a lost shipment. They stopped being fashionable, not being right.

That sentence is the whole design rule we now build xNAUT's agent layer by. It comes straight from walking the graveyard: KQML and FIPA-ACL specified beautiful semantics nobody enforced, and died. Erlang and the tuple spaces made the semantics the runtime, and survived. eGate sat on the surviving side for a decade, and the people who ran it carry the pattern in their hands.

So if that is you: your skills did not expire. They were waiting for the endpoints to get interesting. Dig out the old instincts, dust off the flow thinking, and go build the boring half of the future. The kids can look up what a pencil and a cassette tape have in common.