Autonomous Integrations: From Business Request to Working Code

Autonomous Integrations: From Business Request to Working Code

Webinar Icons Time

Session Time

1 Hour

Webinar Icons Date

Thursday, Oct 22nd

12:00 PM - 01:00 PM CT

Speakers: Dan Magid, CEO & Aaron Magid, Chief Architect 

Most integration projects start the same way: someone writes a detailed spec, hands it to a developer, and waits. This session breaks that pattern.

You’ll see a live demo where AI takes a plain, business-level request, something closer to “connect this system to that one and pull in the order data,” and builds the working integration itself. No line-by-line instructions. No spec document translating business needs into technical steps. Just a request and a result. 

Of course, that kind of speed can raise concerns. When AI writes code faster than any security team can review it, how do you protect your systems? You’ll see how Eradani Connect builds security in from the start and sits between the AI and your systems, so it can reach only what you allow.

This session is for anyone who’s watched an integration project stall because the requirements took longer to write than the code. Stick around for live Q&A at the end.


Transcript

Maia Samboy
Hello, everybody. Welcome to Autonomous Integrations: From Business Request to Working Code. It is noon right on the dot, so we will get this ball rolling so we don’t miss any of Aaron and Dan’s wonderful insights. I’m Maya. I work in marketing here at Eradani. And I will be— we will all be monitoring the Q&A box during the session. So that’s going to be at the bottom of your screen in your Zoom toolbar. Also, at the end, we will have some time for a live Q&A. So might as well put your questions in the box so we can get to all of them. Also, the session is being recorded. You’ll receive a recording afterwards. And if you have any questions after the fact, feel free to reach out to me over email. I’m just maya@eradani. look out for that recording at the end. So thank you for joining us today, and I will pass it on to Aaron to get us started.

Aaron M.
All right. Thank you, Maya, for that intro. So this is, this is a topic that I’m very excited about. We’ve been spending a lot of time internally at Eradani talking about this advancement in AI technology. So I’m excited to take you guys through what we’ve been seeing with this technology. I think that What you’ll see is that it’s a natural evolution in the technologies that have been making their way into our companies, right? You start off with, you know, with a little chatbot that can answer some questions. Maybe it can do some retrieval and pull up some data to help it out. Then you move up to agents that are taking on tasks and doing things working very closely under a human handler. What we’re going to do today is we’re going to talk about how you get to the next level beyond that, not just having an agent. That I can tell it exactly what to do and it comes back and does that one task, works for a couple of minutes and then waits for the next order, but actually becomes fully autonomous on the role that I give it so that it can build and maintain a system on its own and, and actually keep track of it over time so that I can move to an even higher level of directing, steering the ship, deciding what should be built, and then not worrying as much about the specific implementation details, which is, is a place— what we’re seeing is this is a place where AI technologies can function given the right environment. And that, that environment, that’s what we’re going to be talking about here, how you can set that up. Let’s jump in. So what we’re going to do today is we’re going to focus this on integrations. We’re going to talk about an integration application. We’re going to talk about what traditionally has slowed down those projects. What are the problems that we were trying to solve? And how are our agents set up so that we can produce an autonomous environment that takes care of the application? That’s effectively what we’re going to be doing. And we’re going to get to a place here where we can build an entire system and maintain it from a high-level business request without additional information. Let’s go through it. So first of all, in order to understand what the solution is, we have to understand what the problem is, right? Why is it that integration systems and software development has run into problems with autonomy in the past? Why couldn’t we just let systems run on their own? You know, and also, why have human developers had problems with autonomy in the past working in an environment? So the critical piece of human autonomy and the problems there that we see in development organizations Comes down to knowledge and capability. If you have an application where a person has all of the knowledge about a system, and they’re not losing that knowledge, and they’re not getting distracted from that knowledge, and they have the ability to maintain your applications, they can generally take over the whole function. But in most applications, that’s not how things work, right? We can’t have one person doing everything. That’s also a vulnerability in a system, right? Because that one person, you know, becomes a single point of failure. But also, humans have capacity limits. We end up not being able to do that. So the first thing that we need to state in order to get our systems to be able to handle this problem for us is Why, why does knowledge and capability break down in a system? How do we get to a place with humans or technology where a system is able to be autonomous? Well, the problem that we have in a typical development flow is each time a project is handed off, the context degrades. What do I mean by that? We take an application, we take a business request from stakeholders, right? They come at the top level, and that gets translated from business stakeholders who are non-technical into a technical specification by an architect. At that point, we’ve already lost some of the business context that led to the decisions that are being made. Now we’re in a technical context. That architect then writes up a spec To try to transfer what’s in their head down to the developers who are actually working on the project, but that’s never a perfect translation. So more information gets lost, and the developers are trying to reconstitute the architecture and by extension the business context that led to this integration or that led to this project from a limited set of information and from a different perspective than the architect and business users came from. And each stage that we go on from there, development to the working integration to the documentation to the ops team that’s actually handling it in production, we’re losing context every time we do that. What that results in is over time, you take that initial business request, you got this whole world of information as to why you’re doing this. Then in the spec, you’re gonna lose some of that. In the code, you lose some of the spec. In the docs, you lose a bunch of the code because usually the docs are just a projection of what’s in the code, right? It’s usually the same information basically that was in the spec and the code. And then you translate that to the ops team and they’re working with a fragment of the information that that original request had. And what that means is that their autonomy gets significantly reduced, right? We’ve all been— if you’ve worked in software, you’ve probably been in one of those war room meetings that happens Right? Production is down. You’ve got an outage, and you don’t just pull in one person. You pull in the leads from every team that’s related to this system and every part of the application. They all come in, and they’re all talking about what’s going on in the system, right? And that’s because none of them actually have the full picture. So the question is. What if our systems could understand the environment that they’re working in? What if they could understand all of the adjacent applications? What if they could understand the software that’s been built and even the business context and keep that understanding over time so that when issues arise later, they’re able to take action based on that full context, meaning when an issue, when a problem happens in production, they remember the full business context of why the system was built the way it was so that they don’t introduce regressions when they fix a problem? That’s the key question. And that’s what we’re going to explore. So hopefully at this point, our problem is clear, right? Every time an integration passes through another layer, it’s going through handoffs with imperfect knowledge transfer and with different capabilities and different perspectives, and it degrades over time. That creates a problem as we actually want to hand off our integrations. So the question then is, okay, I asked a question, what if our systems could understand themselves? Okay, let’s talk about how we actually get that done because We do get that done. So one thing that I want everyone to understand at this point, there’s a lot of talk in AI circles, you know, and in corporate chats. I see it all the time at lots of companies about what AI can and can’t do. And a lot of that conversation in my experience is biased by excitement or fear. And so I wanna make sure that we say very clearly upfront, AI is capable of this. We’re watching it every day on real applications with real customers. We’re seeing this in real enterprise systems that the agents are actually capable with the right environment. They are actually capable of being the steward of the knowledge about a system, the primary expert about a system. As an example of that,

Aaron M.
I— so it’s one of our persistent agents at Eradani is this agent C2. You may have seen this if you’ve been to some of our other presentations. And what C2 is responsible for is building integrations. That’s what it does. It knows about the systems it’s talking to. It knows about the whole integration landscape. It knows about our corporate standards. It knows our org chart and who it needs to talk to and when. And it’s able to autonomously build systems and maintain them after the fact. So we’re going to be drilling into C2 over the course of this presentation. But the first thing that I want to do here is I want to show you what I did with C2. We’re going to focus on one integration here throughout the course of this presentation, and I want to show you the first thing that I did when I went in to build out this integration with my persistent C2 persona. What I did is I asked it a question. I started off by saying, I’m about to build, or we’re about to build something against the freight shipment data in this ECI EDI demo database on Brave Bartik, which is one of our servers. It’s going to involve DMO204 and DMO204D. What should I know before we move on that project? And I want to be very clear that this question was intentionally phrased from the perspective of, I don’t necessarily know what’s in this database or how it’s structured or even where it is. I just know that I’m about to build something that involves this data. And before I even get into it, what should I know? What are the pitfalls that I should know about as I work on this system? And I want to show you the actual conversation. I actually sent this email. I sent this email. You can see the timestamp on it. Actually, I sent it about an hour ago. And what it came back with, right, the same email, what it came back with is it said, hey, a couple of things that are worth knowing before you build against this. First of all, there are some schema gotchas in here. I re-verified these. First of all, there’s no database-level key constraints on either table. So just be aware of that as you’re working in this environment. Also, every column in this demo204d is typed VARCHAR in the catalog, even the ones that are clearly numeric by name and content. It’s actually a good thing to know, right?

Daniel Magid
Every single thing is— Aaron, Aaron, I’m sorry to interrupt you. Can you make that a little bit bigger?

Aaron M.
Yeah, sure.

Daniel Magid
Great, thanks. Maybe it’s just me because I’m old.

Aaron M.
That’s fine. I’m looking at a huge monitor, so. So every column is VARCHAR. Every column is a character. All right, that might be a problem. I need to make sure that I factor that in in the integrations that I build. Oh, and by the way, also the date columns are decimal, packed as a raw CYMD numeric, right? These are 7-digit dates. Not a real date type. And also one of my favorite things that it flagged is it said the demo data is not meaningfully varied. As of my check, Demo 204 is 34 rows but only 3 distinct values, the same 1 or 2 prototype shipments duplicated many times. The reason I like this is that I think it’s C2 poking at me because I put in the demo data and it’s pointing out that I was a little lazy when I put the demo data in. It’s all the same shipment. And it actually knows that because it has access to the systems. It knows what’s in there and it can actually go look into it and do research for me, right? So it’s actually able to check that out and saying, by the way, also the PRO number on all these is 0. So great, thanks. It’ll still work. But it was one of those things that C2 knows this database better than I do. It knows more about the system than I do. And that’s one of the key points here because it is the subject matter expert about this system. It owns the integrations it builds. It knows about the database, not me. I’m speaking from the business level about what needs to be done. It is the expert.

Aaron M.
So it answered my question, right? First thing that I want everyone to understand is what that’s showing is that it has persistent knowledge over time about this system. It knows the database, it knows what’s in there, it knows how it’s structured. It can look at it in real time and it remembers that information, right? That memory is critical. That memory is what allows it to be highly token efficient. It’s what allows it to be highly reliable over time, to not hallucinate and not get the wrong answers about things, because the amount of work it has to do on most top— on most projects Is minimal because it’s building off of growing knowledge. It has already fit itself to the task that it’s doing, so it doesn’t need to relearn everything every time we give it a project. That makes it faster, it makes it cheaper, and it makes it more effective.

Aaron M.
So let’s take a look at that understanding, because I think that’s a, that’s a critical point in any persistent system, right? The memory is what creates persistence. So the next thing that I did with C2, and I’ll show you this in a second, is had it actually build the integration. And what that request looks like is I said to it, I sent it another email, and I’ll bring this up in a second. I said, we’re about to build something against the freight shipment. Oh, actually, I’m sorry. I got actually the other email. So let me show you that. One second.

Aaron M.
There we go. New integration. There we go. Okay, so actual email. We, we need to connect our freight shipment system on the IBM i to the rest of our stack. That’s what I said to it. Can you pull our freight shipment and commodity line item data out of there, the DMO 204 and DMO 204D tables, and make it available to other systems? Nothing fancy, just something our other apps can hit to get the shipment and line item data. Right? Key points here. I did not tell it where the data is. I did not tell it what I actually— what standards to adhere to. But it knows all of that. When I say to it, Can you pull our freight shipment and commodity line item data out of there? It knows because I said we need to connect this to the rest of our stack. It knows that I want it to build an API interface because that’s our company standard. When I say the rest of our stack, that it knows how the rest of our stack works. It knows that we build Node.js-based APIs and deploy them in Docker stacks out to Linux machines. It knows that that’s how we host our systems. It knows that we use Grafana for monitoring. It already knows all of that information. And so because of that, it’s able to build systems that adhere to our standards without me actually spelling it out every time. So I sent it that request approximately an hour ago. You can see that 11:06. And it came back about 16 minutes later and said, yep, done. Here you go. Demo Integrations now has a read API for the freight shipment data. That’s GET API shipments, all the shipments, each with its line items nested. And the bill of lading, I can— so it gave me 2 API endpoints to help me out with this. And it reads this data and it goes through. Here’s how I did it. I pushed over to this branch in Git. Here’s the commit ID in case you want to look at it. I merged that onto main because I have authority directly to deploy it. So it was able to take care of this entire development project for me.

Aaron M.
And if I go over to my Postman session, I can actually hit this API, API shipments. I can call that API endpoint and it’s going to come back and it’s going to say, yep, here you go. Here’s the data that was in that database, right? These are— this is the information that was in that DMO204 and DMO204D. Right. And similarly, if I take the bill of lading number and I go over here and I put that on the end because it said there was a second endpoint, I can hit that. I have a second endpoint. There’s my data calling the API, right? So I have the integration built fitting to my company standards. One key point here, our company standard is that we return JSON responses with camelCase names. It knows that it can adhere to that standard. Right? Because it has been working on integrations with us for a long time. It’s been working on projects for several months now. And so because of that, it’s learned a whole lot about how our company does things, and it can adhere to those standards as it builds integrations.

Aaron M.
So looking at that process. Right? The system actually is able to build out integrations. It actually is able to remember why and how it built its systems. It knows how it works. It knows why it works. Right? That’s a critical part of building any autonomous system. Now, I want to drill in just a little bit to how its memory actually works, right? Because it was able to build that integration. It was actually able to do that. But how does it actually have access to all those company policies? You know, there are a lot of strategies for this. A lot of agents will maintain a markdown file, for example, and they’ll dump stuff in there, or they’ll use vector RAG over, you know, document groups and try to pull things out of vector databases and try to figure out exactly what’s going on. This process is neither of those. This process, because we are building persistent agents, because that’s what C2 is, it takes on a role and it’s, it’s a persistent AI coworker on our team because that’s how it’s structured. It’s using human memory as a model. If you think about human memory, think about how we actually remember things.

Aaron M.
That memory functions as a series of concepts, relationships, sensory data, and pointers to artifacts in the world, right? For example, if I say a word like sky, it’s going to bring up a couple of other concepts to mind for you. It’s going to bring up feelings, going to bring up what you know about that. It’s going to bring up related concepts. That’s how the memory in C2 works. That’s how this agent remembers things. It can traverse its memories, find related information very, very efficiently. That’s why it can answer questions extremely quickly and extremely cheaply, because it doesn’t need a whole lot of tokens to go redo the research, and it has the information readily available, and It has access to the full relevant context for the question it’s trying to answer and the task it’s trying to perform. That means fewer hallucinations, fewer missteps, faster sessions, lower token usage. That’s what we’re seeing in these agent sessions, in these tasks that we’re giving to our persistent agents. Modeling that concept and relationship-based memory is extremely powerful. And it’s also important to note that it doesn’t have to remember everything. It also links out to hard artifacts in the world. For example, tickets in our backlog systems, database structures and records, files, documentation, things that it doesn’t need to keep directly in its memory, but it wants to maintain a link to. Right. One of the analogies that I like to use for this, because again, we model the memory off of human memory. One of the analogies that I like to use for this is you might not remember, you know, let’s say what your physics professor in college said about gravity that one time. But what you might remember is that upstairs in the closet, in the hallway, in a cardboard box, in a red binder, there’s a page of notes. From that lecture that you went to, right? Or I don’t remember exactly what the statistic was that I read, but I remember where I read it so I can go look it up. It’s doing the same thing. And because of that, again, we’re seeing dramatically reduced token usage, dramatically faster answers, and dramatically more reliable responses. And that’s why we’re able to make these agents autonomous. It’s a major part of the autonomy of that, that sort of that basic step toward how do we actually make them autonomous. Now, just as an example, I actually, we went through some statistics on, on C2. This is actually a real autonomous agent is the one that I’m using for building these integrations. Couple of key points. And I think this is important because of how it differs from me. And how it differs from other agents. First of all, we had one project that I was looking at where the project was built, it went into production at a customer site, and then it went quiet for 64 days. And for 64 days, nothing happened. Working in production, no comments. 64 days later, we got a feature request for an enhancement to the integration. When that came in, I worked on this project. Keep in mind, when that came in, I didn’t remember anything about this project, right? I mean, I remember vaguely what I did, right? But right off the top of my head, seeing that feature request, I don’t know what to do with it. I’m not going to be able to implement that right out of the gate. It’s going to take me time to reconstitute that context and actually be able to work on the project. But C2 took that request Immediately was back there where it was 64 days ago, knew exactly what was going on with the project and exactly why everything was set up the way it was, built out the update in a matter of minutes and was done. That’s part of the power of this system. Extremely reliable memory is a critical piece of autonomy. And another piece to draw the distinction between other agents is on another project. We had 15 back and forth sessions as that group was working out their project and figuring out exactly how the system needed to function, what their business process was gonna be. And across all of those sessions, we never had to tell C2 something more than once because it’s learning about the system over time and getting better and better and smarter as it works on the system.

Aaron M.
The way that that worked, I was leading both of those projects. The way that that worked is that C2 apprenticed under me. It actually was working with me on the projects. It was learning from me. It was asking me questions. And it was reviewing my emails. And then eventually we got to a place where it was drafting emails and I was reviewing them. I gave it a little more autonomy, a little more autonomy, a little more autonomy until it was able to main— to manage and maintain an entire project on its own. That’s how this process works. We take a solid foundation of a persistent Eradani agent with a— with the Eradani knowledge system embedded in it so that it can learn and grow. Set it up under an expert. It can then drop into a new environment and learn how to do the job over time. That’s the key point. That is the most important piece of building out an autonomous system. It’s actually more— the foundation is important. It has to be able to learn. And then what it learns is a critical piece of how it actually becomes autonomous.

Aaron M.
So where are we so far? So, so far we’ve talked about the problem, right? Context loss in even in human teams is a significant problem. That’s what causes individuals to not be autonomous on a project, whether they’re human or AI. Granting your systems understanding and memory that is, that has fast retrieval and efficient storage, that is able to learn concepts, not just dump a document into a folder so that it has to rescan it every time, but actually optimize itself and learn from what it’s encountering in the world so that it can get better over time. That’s the key to— that’s the first step, the most critical piece of building out an autonomous system. So we’ve talked about understanding, we’ve talked about memory, we’ve actually built out an integration, right? I actually had it do that. Let’s talk next about what it does after that point, right? So after it has built out an integration, it’s been a substantial amount of time, as far as agents are concerned, since I had it build that integration. Right? I built the integration about an hour and a half ago. But as far as agent sessions are concerned, if you’re using Claude Code or Copilot or, you know, using one of those agents that doesn’t have a significant memory system, you close your session, it pretty much forgets what you were doing. So at this point, it’s important to note, I don’t have to know everything about this integration. I can if I want. But I don’t have to, because the agent is actually capable of being the steward of the knowledge about the integration. It is actually capable of being the subject matter expert about this integration.

Aaron M.
So here’s what we’re going to do. We’re going to talk to C2 again, and I’m going to ask it some questions that are in the structure that a stakeholder might ask about this integration. For example, where does it get its data? How does it transform the data? What are its business rules? What happens on a weird or a missing value? How would I go about modifying this integration? And I want everyone to notice these are questions that I’m asking to an expert. These are not questions that I’m asking to, you know, to a coding assistant in my VS Code window. It’s not that kind of question. It’s not the kind of question that I’m just asking to an embedded agent. You know, that can just take one task and then forget everything about me, right? I’m not saying look at my open code file and scroll down to this function and tell me how this function works. I’m saying give me a high-level understanding about this integration. What, what would my process look like if I was going to change something? Now, I actually did ask this question over to C2 after it built this integration.

Aaron M.
I asked those exact questions. Where does it get its data? How does it transform the data? What happens on a weird or missing value? How would we modify it?

Aaron M.
And 2 minutes later, I want to just point out the timestamps here because I was doing the asking these questions in real time. 11:40, there’s where I asked the question. 11:42, there’s where I got an answer. Right? 2 minutes later, I get a response. Here’s the write-up on that shipment API and how it works. I know the history of it. I know when it was merged. I know what commit it’s on. I know what APIs are here. I know how it gets the data. I know where the database is. I know how this is all built out. I know what’s left to do in the integration. I know what the gotchas are. I know what the business rules are, right? Because it remembers what it built. 2 minutes, just for reference, for anybody who has used something like Claude Code or Codex, that’s not enough time for an agent to analyze the code that it wrote, right? If you open up Claude Code on something that it has never seen before, And you ask it this kind of question on a bunch of code it’s never seen before, it will need more than 2 minutes to answer that question. And I want to point that out to prove that what C2 is doing is it’s leveraging its knowledge, its history, it’s leveraging what it has learned about the integrations as it’s built them, and also potentially taking a quick look at the code to look at something to get me answers to my questions efficiently and effectively. Right. These answers are very cheap to produce, even though we’re using high-end models for it, because the amount of context that it has to stumble through is minimal. It has exactly what it needs when it needs it, and it has that very quickly. So it can get me answers very quickly. And because it’s not reconstituting the knowledge every time, the opportunities for hallucination are dramatically lower. That means more accurate, faster and cheaper answers.

Aaron M.
So C2 is actually the subject matter expert about this integration. It’s the one that knows how this works.

Aaron M.
Right, the critical scenario here to relate this, because this has been an hour. Okay, fine. But we do this, I mentioned earlier, on a real project, 64 days. Right? So, so imagine on this integration 3 months from now, you have a new engineer coming in and is asked to make a change to the integration. That engineer who has not worked on the project before is going to have to spend a lot of time getting up to speed on this project and talking with experts. If those experts are no longer available, if they’ve retired or moved to another job, that’s going to be very, very difficult. But if the system itself knows how things work, the knowledge never leaves, and it’s always accessible.

Aaron M.
So the key point here is that this process allows us not only to build integrations much faster and much more accurately, it also hardens our system against Staff turnover. We don’t lose knowledge, at least not nearly to the same degree, right? And this is a real process that is happening in real projects. You have an expert work with one of these persistent agents before they retire to apprentice this, to get this agent to apprentice under them and learn how the system works. Gather the knowledge and put it in a place that is accessible and usable and effective, so that when that person is no longer available, the knowledge doesn’t leave with them.

Aaron M.
That’s what becomes possible when we build out these systems. Now, there’s another really cool piece, which is we’ve built an integration. We’ve explained it. We know that C2 is the subject matter expert. It knows how the system’s working, though it’s adhering to all of our company standards. I have delegated this project to it. I’m watching, but I’ve delegated this project over to my persistent agent. Where it gets really powerful is let’s go back to that scenario I gave right at the beginning, right? The war room. Something goes wrong in production and we have to respond. So we pull in all the experts. Everybody’s talking, everybody’s trying to share knowledge and figure out exactly what’s going on. This agent becomes the central store of knowledge about the system so that it can maintain the project on a running basis. That means the system is able— it doesn’t have to reconstruct all the knowledge, it doesn’t have to go stumble through and introduce regressions. It doesn’t hallucinate on building fixes and on diagnosing errors. It’s— it already knows how the system works. And so because of that, it’s able to find and fix real failures very quickly. The key question, right, is in a lot of troubleshooting flows right now, we have a person Who jumps in and digs through the logs and tries to figure out exactly what’s going on when a failure happens. A major part of that is they’re constructing context, trying to remember how this integration works, how the data flows from point A to point B to point C, how it goes from all the different applications to each other, what all the business rules are, why it was built in a certain way, because you see the problematic line of code and you try to remember, well, it seems like that’s Not right, but I know we put it there for a reason. Why was that put there? When the project knows itself, you don’t have that problem because the agent knows why it built the things that it built. It knows the business requirements that led to building that, and as it has the full stack from business requirement to technical specification to documentation, implementation, ops, it knows the entire system. And because of that, it doesn’t have to reconstitute the context, and that massively reduces the opportunities for hallucination.

Aaron M.
What this allows is setting up the agent to actually watch the systems that it has built. That means your integrations are dropping data into an observability stack. For example, Grafana. That means logs, metrics, traces. Those are all being tracked. Instead of visualizing those on a dashboard for a person, we make those queryable by the agent. That means that it can leverage its knowledge. It can be notified about a failure, leverage its knowledge to understand what that failure means, why it happened, what the likely causes are, where it needs to go, And then propose fixes to the system that don’t introduce regressions because it knows the whole history and why each piece works the way that it does. So it’s not going to introduce a fix that breaks one of the key business requirements. Right? One of the big things that happens if you’ve ever tried to maintain a system with a base Claude code or Copilot. Is they’ll oscillate on solutions, right? It does a solution, it implements a solution, something goes wrong, it implements a different solution, something goes wrong there, flips back to the first solution because it forgot what it did yesterday. That’s not a problem when you have a persistent agent that actually owns the project. Now, I did this with a real failure.

Aaron M.
I ran an API call. And the logs for the API came back and they said, no DMO204D commodity rows matched your shipment’s join key. Why? Because I gave it 515611 in here on the slide. You can see that in red, but the actual value is 515— is left padded with zeros. And remember, we said at the beginning C2 flagged for us The database is all varchar fields. It’s all character data. So the integration assumed that it could actually parse out a value as a number, or the user assumed that they could use a value as a number, but it’s not. It’s character data. So that created a problem in the integration. I gave that to C2. To diagnose and resolve. And it came back within a minute with the exact root cause, the responsible lines of code, and a working fix proposed and deployed into the test environment. Because it knows how the system works, it knows what those log lines mean, and it has access to all the systems that it needs to actually work in the system reliably. That’s what allows it to be reliable in this system. It’s what allows it to maintain the integrations that it built.

Aaron M.
Alright, so we’ve talked about building out integrations. We’ve talked about knowledge transfer, memory, why the systems are able to be autonomous, why they’re able to build out their— why they’re able to build out integrations effectively, why they’re able to maintain systems. There’s a key question here that we haven’t addressed, which is, how do I trust it? How do I know that this persistent agent is actually trustworthy? Right? How do I know it’s not going to be the victim of prompt injection? How do I know that it’s not going to hallucinate and go off the rails? How do I know that it’s not going to access something it’s not supposed to access?

Aaron M.
This is a major part of our work at Eradani. This system has a multi-layer security system that sits around the persistent agent that makes sure that it is reliable. But one of the key principles that I want to point out here is that the agent security, you know, in autonomous systems, Security is— this is not a new question. We’ve been asking this question, how do I trust an autonomous agent on a system? We’ve been asking that question forever. How do I know that a human on my team isn’t going to take an action that I can’t trust? How do I know that they’re not going to do the wrong thing? How do I know that they’re not going to do something self-serving? Right. It’s the same problem. We’re just dealing with it with a different type of user. At a high level, the security model requires separation of duties between agents to make sure that no one agent has the ability to take the entire system. Explicit authorization for growth in capabilities so that when the agent tries to do something new, we’re checking it when it tries to make its own tools or optimize itself. We’re checking that and making sure that it is actually trustworthy. Significant investment into prompt injection scanning to make sure that the agents can’t be hijacked, and that if something is submitted to an agent that’s malicious, that the damage is tightly constrained and immediately visible, including auditing and logging of every agent session, every thought that the agent thinks, every action it takes, every message it sends. Is logged in the system and analyzed for security and for optimization opportunities. Right? That’s what allows us to say that we can trust these agents. Right? It’s a multi-layer model that says, I can see everything they’re doing. They’re hardened against malicious action. And if any agent does actually receive something malicious and does actually read it and does actually treat it as data, it doesn’t have the authority to do anything damaging because it’s part of a broader team that has multiple different points where multiple different persistent agents are managing multiple different critical responsibility areas, right? That means no one agent is actually capable of causing significant damage to the system. And We know everything that every agent is doing. So the moment something comes in, even before it’s able to cause any problems, we know that it’s there. There’s a lot more here. This is not officially a security webinar, but there’s a lot more here. And I wanted to bring this up from our design documents about the— about our persistent agents to show what’s in here, right? Credential injection proxies, destination-bound credentials, secrets not hitting the agent context, conventional code scanning, deterministic deployment gates. Right? Artifact integrity, hash checks, tamper-resistant audit trails, agent security classes, right? We’re building out a process. We have built out a process that allows these agents to be trustworthy. That’s why we trust them. That’s why these agents are able to work on projects, right? They are able to be autonomous because of the security and knowledge models that are powering them. All right, we’re coming to the end of our time here. So I just want to take a minute to look back at where we are.

Aaron M.
These persistent agents that we’ve been talking about, they understand our systems. They remember our systems. They remember how they work. They remember what they did. They build integrations. They explain those integrations after the fact and maintain them as those integrations live out in the wild, and they’re secure and trustworthy. Those pieces are what allow us to delegate the problem of integration over to the persistent agents so that we don’t have to worry about it anymore. We get to then move up to a higher level where we’re focused on business requirements and steering the ship rather than being focused on the individual steps that are happening at the implementation level.

Aaron M.
There’s one more thing that I wanted to mention. You know, We’re talking about integrations here. This is the full picture of how autonomous integrations work. This is how you can build out an autonomous integration, how we can get these systems to be autonomous and to manage themselves. But as we were working on this platform, there was an interesting realization that came up, which is If you look back at what we talked about, and this is where we’re applying this technology in other places, what we did is we had a persistent agent learn an enterprise system, keep what it learned, build software from a plain business request, explain what it built, diagnose a real failure in it. None of that is actually specific To software that happens to be running an integration, right? Reading data, applying business rules, transforming data, producing a result. Most applications are functioning in that structure. Learning an enterprise system, keeping what we learn, building software from business requests, explaining what we build, and diagnosing failures is what we are doing as engineers. So the key point that I wanna bring up here is we have a technology now that allows us to move up in the world as opposed to working on the day-to-day code, as opposed to getting into the actual lines in the system, in the actual documentation, actually writing that into the running the actual commands to do system maintenance. The systems are becoming capable of maintaining themselves. I want to be very clear about this. This does not mean that we as engineers don’t have a role, but it does mean that our role is changing. It means that we are moving up. This is the same transition. I was telling this actually to, to my team recently. This is the same transition that we’re all going to go through. As this technology hits both through Eradani and in the general AI industry,

Aaron M.
this is the same transition that senior engineers make when they move up into leadership, right? When you move from being a senior engineer to a chief engineer, when you move from being a senior architect to a chief architect or a CTO, it’s the same transition. That you’re making, which is I’m not in the code anymore because I’ve moved up. I don’t necessarily care what each line of code is doing, but I care that the business requirements are being met, and I’m delegating to a team I trust to build out the actual code and to actually deliver it. I’m constructing the team. not the actual code. I’m giving the instructions for what it should do, not actually implementing it. I’m approving or rejecting changes to business scope, not writing code and writing documents. And I wanna drill this in because I think this is a critical transition that we as engineers need to be ready to make because this technology is coming. We’re already doing it. And other agents are also moving into this persistent space. This is the next frontier of the AI agent development. Now, I have an application here where I often do this with other systems. But I actually wanted to turn this over to Dan to give us a view of how this looks in, in working on a real application that’s not an integration application, because we’re seeing some very powerful advancements in these systems, whether they’re integrations or not. So, Dan, give this over to you.

Daniel Magid
Great. Yeah, this is going to be brief. I just want to show you kind of a look under the covers of what happens with the agent. What’s actually going on? Let me go ahead and share my screen with you all.

Daniel Magid
You should be looking at me. I’m in my Visual Studio Code environment. I’ve got an IBM i application out here that’s in Git. I have it in Git so that the agent can understand the application. The first thing I did here is I asked it a question. I said, I’ve got these programs, the CUAPGM to CUAPGM07. What do those programs that start with CUA do? What do they actually do? So it actually gave me an answer to that question, explained exactly what they do, and then it actually created a flow diagram for me and stuck that into the repository, which now is part of its knowledge base. So it no longer has to go in and analyze what they do, it now has that information. The next thing I did here is I said, can you add a salesperson first name and salesperson last name to the customer master table? Can you add an option to generate a report from that data and send it out to a spool file? Again, that’s all I said to it. I didn’t tell it anything else, and it went off and said, okay, let me go work on that. It said, oh, in my knowledge base, I have specs for how to build everything. I know if I go in and start changing these things, I don’t have to analyze the application to figure out what create commands you’re using, what options you’re using. I have all that information in my knowledge base. I can go ahead and build this. I can make the changes, I can test the changes, and I can push the changes up to the repository. If I go in and actually look at my repository, so here’s the repository and I’ve got this task that it actually created. It created this branch. Now, the AI in its knowledge base knows that it has to create all of its stuff in a separate branch. It does not have access to move any of this stuff to production. It creates it in its own branch and then somebody has to take a look at it. But I can go in here and say, oh, okay, so here it is, add salesperson fields to cust master and a customer listing report. Let’s just take a look. Here is what it wrote. So it wrote the documentation for me of what it was doing, what this task was about. Then down below, I actually can see here’s what it actually did. Here’s all the changes it made. It actually created the printer file here, so I can see that. I’ve got all the information of exactly what did it do in order to implement that change. Again, all I did was say, here’s what I want you to do. Again, as Aaron showed, you could have sent it an email and said, here’s what I need you to do. But under the covers, it’s doing all that, and it’s doing the stuff of working with the Git repository, doing the Git adds, the Git commit, the Git push. All of that’s happening for you, so you have the history of everything that’s been done. So when it comes time to move this to production, whoever has to review it has a very easy way of seeing exactly what was asked and what was changed. The other thing I could do is I can go in and say, well, so I also see, we go back over here to its commits. I had another project that I had it do before that one, which was I just want you to go look at it and fix any issues, any defects that are in the programs, which it did. But it also then automatically just generated the documentation for the application because that was the first thing I asked it to do. If I go in here and look, it’s generated the documentation and put that again into its knowledge base, into the repository, so it never has to do this again. But it shows me information about the application. Here are the objects in the application and what they all are. Here’s the high-level flow of how data flows through the application. All of this stuff it just built because it knows what it is that I want it to do, and so it automatically did that. The entire process was I gave it something to do, could have been an issue from my Jira backlog or ServiceNow backlog. Here’s what I need you to do. It then went to its knowledge base and said, okay, so what are all the files I might need to access to implement this? It has that information. Again, it doesn’t have to analyze the application again to figure that out. It knows the build rules, so it knows how to build things because it looks at the build information. It doesn’t have to go reanalyze everything to get that. All that information is in its database. It knows the process it’s supposed to use. It actually knew our naming conventions for naming branches, so it named the branch something that starts with task because that’s how we name all of our branches. So it created a branch for the task. All of those things are being done automatically because it has that knowledge base. It has the information inside its knowledge base, and here’s the branch it created. It created that branch, did everything on that branch. It did all its work and then it pushed it up the repository. Now it’s just waiting for the next person to say, okay, I approve the changes that you’ve made. But again, whoever is doing that has a really easy way of seeing everything that it did. It’s taking into consideration the security model, our coding standards, all of that are in its knowledge base. Anyway, I just wanted to give you an example. That’s obviously something that’s not an integration, that’s just the standard project you might do. By the way, I did all of that and had it implement that. I have not coded since RPG II, so I just gave it the information. All right, Aaron, I’ll turn it back to you.

Aaron M.
Yeah, I’ll take this and wrap this up. So the full picture that I want to make sure that we get out of this, right, is when we have a system that is capable of autonomously managing an application, we can hand off the system to it, we can delegate responsibilities to it. And as a result of that, the system’s able to autonomously maintain systems, whether they are integration applications or general applications. This is not just a new way to build integrations, right? This is about software build— building and maintaining software in general. These persistent knowledgeable members of our teams are able to build whatever we need and maintain them. So I hope that was useful. I hope there’s some concepts you guys can take with you from the technical side around the memory and security models. Yeah, and I hope that was helpful. Any questions?

Aaron M.
Great question. Okay, so I see a question. All right. So number 1, could I provide some details on technologies that the agent is built on? I see that one. Do we use MCP servers, N8N? So this agent environment is— can utilize— it’s agent and model agnostic. We do have a custom agent in here. It does support MCP servers. It’s not built on top of N8N, though it can integrate with it if you want. And it does not communicate with systems of ours. The agent is hosted entirely in a sandbox on-prem in your environment. It’s not a cloud-based system. It’s something that you provision our agent, our persistent agent management platform in your environments wherever you want it. and drop in agent containers and start allocating responsibilities. We don’t need any access to your systems. You don’t need any access to ours except for downloading product updates. That’s how that works. How do— let’s see. Hold on. Let me just see.

Aaron M.
Okay. How did I manage to decrease— how do we manage to decrease token consumption and time needed to process the request as well? The idea of I know where my book with my lecture notes lies. Is simple as a prompt telling where the other prompts are? Yeah, great question. So the key thing here is when you run a persistent agent for a long time across multiple projects, that’s where markdown files or one prompt telling where the other prompts are, it’s where those systems break down, right? Because if I was to say, you know, give you an example, right? So Claude Code’s default memory model, Is it maintains one running file with titles of memories, and then each memory is a markdown file. And it knows the titles of all the memories every time you start it up. Okay, but in order to actually know what they say, it has to open the markdown files and read them now. And there’s no relationship to related context or concepts. So when you’re working in one project, or when you’re working in a session, That works pretty well because it all fits in the context window. But once your agent runs for days, weeks, months, or years on multiple projects, that just becomes context bloat. The data becomes useless. It’s not providing— it’s slowing down the agent. It’s burning tokens, and it’s not providing any useful information, right? You need a memory system that’s actually able to deliver correct information. that is in scope, even when you have learned thousands, tens of thousands, or hundreds of thousands of different concepts and relationships. Even when you have gigabytes or terabytes of data, you have to still be able to sift through it and find the right information effectively. That’s the key design, because what you’ll see is when you run a persistent agent for a while, the memory grows very quickly. And that’s where those, those other systems

Aaron M.
Run. As for how many integrations do we have working in production already? Are because these systems, because our Eradani Connect APIs are on premise, we don’t actually know how many our customers are running. So unfortunately, I actually can’t answer that.

Aaron M.
But I guess that actually proves back to point number one, which is that. It doesn’t connect to our systems. It’s not on our production systems.

Aaron M.
All right.

Maia Samboy
If I know we’re at time, but if you have a sec, Aaron, there’s a question I see in the chat here. How do you stop it hallucinating or making a destructive change on a live system?

Aaron M.
Yeah. So that, I think, I think that goes back to the memory and the security model. You know, when we talk about how do we stop it from hallucinating, it’s 2 different things, right? How do you stop it from hallucinating? Hallucinations, you know, I really like the human model, you know, when you kind of think about these technologies, right? Hallucinations are what happen when the agent gets creative because we didn’t give it some information it needs. You tell it, I want you to build an integration, but you don’t tell it what protocol to use. Okay, so it comes up with something, right? Or I want you to build an integration with my database, but it doesn’t actually have your database. And so what it does is it makes up your database and it’s wrong, right? When it has access to the systems it needs to work with, when it has a comprehensive knowledge system, and, and when it knows this is what you know and this is what you don’t know. Right? It’s able to detect and deal with hallucinations much better, right? Number one, it typically will have the information it needs, and that information can be validated against the knowledge and against the official knowledge base of the agents. And again, same process as how it loads it very quickly, it can validate it very quickly, which helps it ensure that it’s not hallucinating. So it’s less likely to hallucinate, and also it knows that it shouldn’t make things up because it should go to that memory system that generally is going to have what it needs. As for making destructive changes, generally speaking, what we’re finding is that with the right knowledge, they often don’t even propose destructive changes. They generally understand their systems and they know what the impacts are going to be. That reduces the number of proposals of destructive changes. But also the security model is built around blocking destructive changes. So meaning even if you have an agent that tries to do something that it’s not supposed to do, between the separation of duties and the auditing and the tool authorizations, it generally is not going to be able to go out of scope, right? A great example of separation of duties is you don’t give the same agent access to build and maintain integrations as you give to access production data, right? Because then you’d have one agent that is able to modify production data to suit its integrations. And you can have a hallucinating agent say, oh, I really wish the database looked like this so I could build my integration better. And then it can actually change the database, right? That’s— you separate those so that into multiple separate distinct persistent agents with different knowledge and different authorizations, same way you do with people. so that they can’t do something even if they want to. They can’t do something that they’re not supposed to. That’s— I think that’s really what it comes down to, is knowledge and security.

Maia Samboy
Okay. Well, thank you so much, Aaron, and thank you everyone who stayed a little longer for us. Keep an eye out for that recording in your inboxes. It should be there tomorrow. And we hope to see you guys next time. And again, if you have any follow-up questions or anything like that, feel free to reach out to us and I can connect y’all with Dan and Erin. Thank you so much and have a great rest of your Thursday.

Daniel Magid
Great, thanks everybody.

Aaron M.
Thank you all.

Maia Samboy
Thank you.