144 - Understanding Agents Part 9: Hermes Agent

This podcast is a project of the AI ​​Guild. The content and voices are generated with AI and are used for information and demonstration. Have fun listening. So, welcome to the ninth episode of the AI ​​Guild Podcast. A pretty fundamental law of artificial intelligence is actually that language models have absolutely no memory. That's right, zero memory. Exactly, if you chat with such a model and then simply close your browser window, then you are basically dead to this system. It starts all over again at the next conversation. Yes, it is completely stateless by nature. It gets text in, spits out text, and can't actually learn at all. But, and this is the reason for today's episode, since March of this year a completely new system called Hermes has been breaking this iron rule in an almost provocative way. And how it does that. So today we're looking at this Hermes agent, which in just a few weeks has established itself as an extremely solid, I would almost say revolutionary basis for agent systems. Yes, that happened really quickly. Absolutely. And the most fascinating thing about it is this one contradiction that we want to completely unravel today. Hermes presents itself to the outside world exactly like an ordinary language model via a completely standardized programming interface. But in the background, deep in secret, so to speak, this agent is actually continually learning from its experiences. And that is exactly the architectural masterpiece that we want to dissect in detail today. We really want to go to the mechanical level and understand how this agent translates our theoretical development stages into real practice. Because that's always been more of a theory, right? Right, exactly. Because what Hermes is doing, pretending to be something completely simple while a highly complex machine rattles in the background, simply solves one of the biggest problems in our industry. Okay, then let's start with this perfect illusion. I imagine it to be something like this. Hermes basically puts on a costume and tells my software that, ah, hello, I'm just a normal, simple language model, just send me your text. Yes, that's a nice picture. What exactly happens the second I as a user type a question into my chat interface and, well, hit send? So, the process is mechanically solved in a really fascinating way. When your user interface submits this question, it sends it to a completely standardized programming interface. For your user interface, i.e. the chat window that you see on the screen in front of you, it all looks as if it were simply communicating with a very common text generator. So everything as always. Exactly, everything as usual. But, and here it comes, in the exact millisecond in which this request arrives at Hermes on the server, this magic trick happens. It just doesn't start with a simple, er, stochastic completion of words. Rather? Instead, the request is essentially intercepted and a complete autonomous agent cycle is initiated. The system pauses for a moment, first analyzes the content of your question, then comes up with a multi-stage plan, calls up various tools, and then perhaps carries out three or four internet searches completely independently. Craziness. Yes, or it reads local files, critically evaluates all these intermediate results and only then summarizes all this collected information in a coherent answer. You know, this totally reminds me of going to a really good, let's say upscale restaurant. You come in, sit relaxed at your table and order from your waiter. And in our analogy, this waiter is now the simple language model. Oh, that's a great comparison, yes? You just tell him what you want and expect him to bring you the finished plate a little later. What you absolutely don't notice from the dining room is the huge, perfectly orchestrated chaos back in the kitchen. The hut is basically on fire. Exactly. There is your agent, there is frying, there is the chef calling out his commands, there sauces are being reduced and fresh ingredients are being fetched from the cold storage. And when the masterpiece is complete, the waiter wipes his hands, walks through the swinging door, completely relaxed, and serves you your food with a smile. You only see the final result. And you have no idea about the hard work behind it. All the intermediate steps, all, well, even all the burnt attempts in the kitchen, they simply remain hidden from you. Correct. But now let's ask a provocative question. Why is this huge game of hide-and-seek even being pursued architecturally? That must be incredibly complicated. Well, the answer to that is actually simply seamless backwards compatibility. What do you mean exactly? Why is this so much better than simply showing the user directly what the agent is up to? Imagine how many systems, business software, mobile applications and chat programs are already out there in the world. They have all been programmed in the last two years to send stump text to a language model and expect stump text back. Okay, that's probably millions of applications. Exactly. And if you suddenly had to teach all of these thousands or millions of systems to communicate with a real, complex agent, a system that suddenly asks questions, that reports, I'm starting a web search now or I'm loading a document now, then you would have to rewrite countless numbers of code. Ah, I see. They would probably just crash, right? Absolutely. The user interfaces would crash because they cannot understand these complex status messages. But with this Hermes architecture, any existing system can suddenly harness the gigantic power of a highly complex agent without having to change a single line of code in the original app. This is actually brilliant. Yes, you simply swap the target address of the programming interface in the background and boom, you've done a massive Agent Tits upgrade. Okay, now if we mentally walk through that swinging door into the kitchen, we definitely need to talk about the tools that the chef has at his disposal. In our development stages of an autonomous AI agent, the integration of tools is a massive leap. How exactly is this solved at Hermes? So Hermes has more than 50 different tools. 50? That's a lot. Yes, and the spectrum is huge. This ranges from very simple operations such as simply reading a text file to full administrative access to a system terminal to fine-grained control of an entire web browser in order to visually analyze websites. Craziness! And the real highlight of the whole thing is the registration architecture. With older systems you usually have a gigantic monolithic configuration file. If you want to add a new tool, you have to adapt the entire code, register the tool, maintain the descriptions and then laboriously restart the entire system. Yes, I know that. This is extremely annoying. Even. And Hermes does it radically differently. The tools are modular, standalone files. When you need a new tool, simply drop this file into the appropriate folder on your hard drive. Just drag & drop, so to speak? Almost, yes. And on the next run, the system automatically recognizes the file, reads its capabilities and integrates it into its repertoire completely independently. Wait a minute, I have to jump in there. You say the agent has access to over 50 tools at the same time? So from my own experience I know that if I put even three or four different tools in my hand on a commercially available model, then it often starts to hallucinate wildly. Yes, the classic problem. Exactly. It then uses the terminal when it should actually use the browser or invents some parameters that don't even exist. With 50 tools, how on earth does Hermes not completely collapse under its own complexity? This is a completely legitimate question and exactly the problem that many developers regularly despair about. Hermes' solution here lies in extremely strict structuring of the system instructions and clever pre-filtering. The model doesn't just have all 50 tools thrown at its feet in an unstructured manner every millisecond. Ah, okay. That means it is portioned. Exactly. The system architecture groups these tools logically and gives the language model extremely precise guidelines as to which category of tools actually makes sense in which phase of problem solving. The system also uses its memory to learn which tools have delivered the best results for you as a user in the past. Which brings us to perhaps the most important point today? The memory. At the very beginning we opened up this big contradiction that this system doesn't forget. How does this learning work on a purely technical level? So Hermes used a concept that is based on three different levels of memory. For our consideration today, the most exciting level is actually the so-called curated memory. Okay, what exactly does curated mean in this context? Well, please don't imagine this as a simple chat history in which everything is simply written down word for word. Instead, the agent silently observes the progress of your conversation in the background. If he then gains an important insight about you, for example that you always prefer programming code in a very specific language or that you prefer your answers to be extremely short, then he writes himself structured notes on his own. Aha. And now comes the mechanical trick that makes the whole thing really efficient. At the start of each completely new session, a quasi-frozen snapshot of this collected memory is taken and hard-loaded into the system's basic behavioral instructions, i.e. the system prompt. Wait, wait. Here too I have to ask critical questions again. You say a frozen snapshot is loaded at startup. To be honest, that sounds like a huge bottleneck to me. What if I've just had a really in-depth conversation with the agent for half an hour and my preferences change completely during this conversation? OK. I see what you're getting at. Because if the snapshot is frozen, won't the system access stale data all the time and completely ignore my change of heart? That is a very, very strong objection. At first glance it actually seems rigid. But this is exactly where one of the most brilliant optimizations of this entire architecture lies. Here we have to briefly look at the costs and the computational effort of a language model. Which aren't exactly small. Even. Normally, a model like this would have to completely re-read and mathematically calculate the entire previous conversation, including all system rules, from the very first syllable with every new question you type. This costs an immense amount of computing power. And the concept that Hermes uses here to get around this is called prefix caching. Prefix caching. Okay, explain that briefly. These large, consistent text blocks of memory, i.e. our frozen snapshot, are only calculated once and then stored in the buffer, essentially directly in the graphics card's RAM. This saves a lot of time and, above all, money. Ah, I see. So he doesn't have to read through this thick tome of rules every time, but has already internalized it. But what about my new preferences from the current conversation? This is exactly where a very clean separation comes into play. The prefix caching does not mean that the agent is forgetful or suddenly inflexible. What the agent learns in this very second of your current conversation is stored in its dynamic short-term memory, i.e. the active context window, so that it can respond to you immediately. Okay, so that's separate. Correct. And if it learns a really fundamental new rule, it immediately writes this knowledge to the hard drive in the background. However, he deliberately only applies this newly written rule for his fundamental long-term behavior when you start a completely new session. That's clever. Yes, because this prevents the agent from suddenly radically changing his entire personality or way of working in the middle of the flow. It is an extremely clean separation between deep long-term knowledge and the highly dynamic temporary flexibility of your current conversation. This is really an extremely elegant solution and actually clarifies the contradiction from the intro. But when we talk about adaptation, I would like to go a step deeper. How exactly does the system really teach itself fundamentally new things? What exactly do you imagine by that? Well, when I think about real self-improvement in artificial intelligence, I always have this image in my head of researchers calculating huge matrices and adjusting neural networks, changing weights and completely retraining these models for millions of dollars. It is precisely this image that we now have to completely erase from the minds of agents like Hermes. Hermes uses a so-called skill architecture, i.e. a skill structure that is based on a completely different paradigm. What does that look like? When Hermes is faced with a very complex, completely new task, let's just say it has to convert an extremely exotic file format without errors. And then, after a few failed attempts, he successfully solves this problem through the clever use of his tools, then he doesn't go and try to adjust his internal neural weights. That would be far too unstable and extremely error-prone. Then what does he do instead? It simply creates a structured text file, a so-called Markdown file, completely independently. In it, he writes down in completely natural language the exact instructions, the logical path and the specific tool calls that led to this success. Wait, if I understand this correctly, the agent doesn't reprogram itself in the traditional sense, but rather simply writes itself a very detailed cheat sheet for itself? Yes, exactly. Just like a craftsman who, after a really complicated job, hangs a note on the noticeboard in the workshop that says, if another job like that comes in, take the ten-key straight away and ignore the red screw. There really isn't a better way to put it. That's exactly how it works. And the scope of this mechanic is extremely important for all of us here to understand. True self-improvement in modern intelligent systems absolutely does not have to involve complicated math or expensive new training runs. Purely declarative notes are sufficient. That's crazy. When Hermes boots up on a later reboot, it simply searches through its own ability folder, finds this newly written cheat sheet, reads it, and fully automatically recognizes it as a brand new, established ability. The agent has taught himself a new skill simply by writing down his hard-earned experience in natural language. You know, the reason this fascinates me so much is because it minimizes this structural danger. When you rewrite a neural network, you always run the risk that the model will suddenly forget how to speak German without errors because some weight has shifted internally. The so-called catastrophic forgetting. Yes. Exactly. But if Hermes simply writes an incorrect cheat sheet, then in the worst case scenario you as a user will simply go to the folder on the hard drive and delete this one small text file. This dramatically lowers the barrier to what we even define as learning. Absolutely correct. It makes learning transparent and, above all, revisable at any time. Let's broaden the perspective a bit again. Until now it all sounded like I was sitting in front of a chat window all the time and just waiting for replies, right? Definitely. And architecturally, Hermes is by no means limited to existing on a single user interface on your screen. He is on 15 different channels at the same time. 15? Yes. You can communicate with exactly the same core agent across your various messenger services. You can write him an email or integrate him directly into your smart home via an interface. The system that makes the decisions and accesses the memory always remains exactly the same in the background. Only the output channels are extremely diverse. This is super practical. But what really blew me away when I studied how it works is how proactive it is. The system can handle time-controlled execution. Oh yeah, that's a huge feature. For listeners who may not be as technically involved. This means that I set up so-called cron jobs. These are commands that run in the background according to a fixed schedule. So I no longer have to actively contact the agent to get him to do anything. Correct. You can instruct Hermes to wake up completely autonomously every morning at exactly 8 a.m., use your browser tool, search certain financial portals for very specific indicators, load the data into your local memory and analyze it. At this moment, the agent acts completely detached from any human input. And the moment where that proactivity went from useful to absolutely awesome for me was this concept of delivery rotation? Yes. When this agent takes action on its own in the morning and creates this complex report, it also decides completely independently at that very moment where this result will be sent. It is connected to these 15 channels. Exactly, he has free choice. So he can analyze, okay, this information is extremely critical today, I'll send it immediately via messenger directly to my user's phone. Or he says to himself, well, this is just routine data, I'll just put it silently in an archive without disturbing the user at breakfast. For me, this autonomy in the distribution of information is actually the epitome of a real agent. And that inevitably brings us to another extremely powerful component of this entire network. Hermes makes extensive use of MCMP. Ho, of course that changes the rules of the game completely? Absolutely. The brilliant twist here is the direction of communication. Normally we know that an agent acts as a consumer; he uses external tools to fulfill his task. But Hermes makes itself available as an MCMP service for other systems. He basically offers himself? Exactly. He offers his agentic abilities, his memory and all his tools to the outside world. This really turns the classic architecture that we have previously known in the industry on its head. When I listen to all of this in one go, i.e. a system that juggles 50 tools, that writes its own cheat sheets, that networks over 15 channels and wakes up by itself in the morning, then a question inevitably comes to mind. What happens if we combine several of these highly potent agents together? The hive idea. Exactly. If I have a main agent delegating tasks to specialized sub-agents, won't there immediately be total, uncontrollable chaos when each of these little agents starts using their own tools, writing their own text files, and wildly changing system behavior? This risk of complexity explosion is absolutely real in multi-agent systems. And to be honest, this causes many projects to fail in practice. But Hermes' architecture solves this problem through deliberate, very hard isolation. What does it look like? There are very strict restrictions on subordinate agents. If your main agent delegates a complex sub-task to a specialized child agent, then this child agent is essentially put in electronic handcuffs. For example, under no circumstances may he delegate this task to other agents. Ah, okay. So there is no endless chain of subcontracts that take on a life of their own. Correct. And even more important. The child agent is never allowed to write directly to the main system's curated long-term memory. Understand. So it's pretty much like in a large company. You have the manager, who is our main agent. He has full access to the company strategy and files. If the managing director now purchases a highly specialized external consultant for a specific analysis, then this consultant can complete his task and dutifully submit the report. Exactly. But the consultant does not have the authority to secretly rewrite company guidelines at night or to set up new departments on his own initiative. This is an absolutely perfect comparison. It is precisely these clear, hard boundaries that prevent chaos. In the world of multi-agent systems, restriction and isolation are, paradoxically, the absolute key element for freedom and stability. Without these strict guardrails, the system would likely collapse within hours. We have now talked a lot about the achievements and the skills. This actually leads us to a point that, in practice, often means the end of such projects. The resources. Oh yes, the love money. ...devour costs. How on earth does the system ensure that it remains economically efficient? Here we enter the fine art of intelligent rooting. The developers quickly realized that not every question requires the same amount of intelligence. The system knows that you don't have to start the largest, most complex and most expensive language model for every trivial task. Let me guess. The system does a kind of triage, like in a hospital emergency room. Is that what you mean? Well, if I come to the clinic with a small scratch on my finger, then I don't need the head of neurosurgery who costs thousands of euros an hour. A friendly nurse who puts a plaster on me is enough. Only when I come in with a highly complex problem will the expensive specialist be called out of bed. This is exactly how Hermes’ intelligent voting works. If you make a short, simple request that consists of fewer than 28 words, such as asking for the current time or a very short translation, the agent will recognize it immediately. And does it go any further? Exactly. It quickly forwards this specific request to a very small, extremely cheap and responsive model. This model then basically sticks the plaster on. Only when the task is really complex, when deep logical analysis, complex programming or long-term planning is required, only then are the big analytical heavyweights ramped up. That makes perfect sense. But how does the system deal with the burden of endless conversations? If this agent wakes up on its own in the morning, collects data all day, and I continue to discuss with it for hours in the evening, then the entire context memory window inevitably feels wider and wider. At some point the system simply bursts at the seams. Here, too, a fascinating resource intelligence comes into play. The system constantly monitors the level of its own working memory. When the active conversation window is 85% filled with text, the system sounds an internal alarm. And what happens then? Then one of these small, inexpensive models switches on again in the background, completely unnoticed by you as the user. His only highly specialized task is to read the extensive history of your previous conversation and summarize it in an extremely compact manner. So it cleans up. Correct. This compressed text then replaces the page-long protocons in memory. This immediately frees up valuable space again, without the actual large main agent being burdened with this trivial clean-up work or without important contextual information from the past being lost. Craziness. Let's really get to the heart of it for you as a listener, why it's all so incredibly important. If you ever plan on building or using an agent that runs 24 hours a day, seven days a week in your business or even for yourself, then this efficiency isn't just a nice little technical gimmick. Absolutely not. This is business critical. Exactly. This clever distribution of inexpensive models for light tasks and automatic compression at 85% fill level is, at the end of the day, exactly what determines the financial feasibility and actual operating costs of your entire project. These mechanics literally make the difference between a priceless theoretical lab experiment and a productive system that can truly scale out in the real world. I can only absolutely agree with that. A revolutionary technology is only really revolutionary if it can also survive economically in the harsh reality. And here Hermes simply shows in a very impressive way that it is not only cognitively powerful, but also extremely mature structurally and economically. Well, that brings us to the end of our deep dive into the truly fascinating mechanics of the Hermes agent. We hope we were able to give you a tangible insight into how the future of autonomous systems is already being built in the background. Yes, it remains an incredibly exciting time. Definitely. On behalf of the entire AI Guild, we thank you for listening and say goodbye to you today. But, and this is also important to me, we don't want to dismiss you after all these technical depths without giving you one final, perhaps slightly provocative thought. I'm excited now. Tonight, just think again about our image of the elegant restaurant and the hidden chaos in the kitchen. A very good question. Or perhaps you have already been sitting opposite a completely autonomous agent who, while you are still waiting anxiously for his answer, has already independently searched half of the Internet and made in-depth analyzes about you. Think about it. See you next time.

Dieser Podcast ist ein Projekt der KI-Gilde. Die Inhalte und Stimmen sind mit KI erzeugt und dienen der Information und Demonstration. Viel Spaß beim Hören. Also, willkommen zur neunten Folge des KI-Gilde-Podcasts. Ein ziemlich grundlegendes Gesetz der künstlichen Intelligenz lautet ja eigentlich, Sprachmodelle haben absolut kein Gedächtnis. Richtig, Null-Gedächtnis. Genau, wenn du mit so einem Modell chattest und danach einfach dein Browserfenster schließt, dann bist du für dieses System quasi gestorben. Es fängt bei der nächsten Unterhaltung komplett wieder bei Null an. Ja, es ist halt von Natur aus völlig zustandslos. Es bekommt Text herein, spuckt Text heraus und kann eigentlich überhaupt nicht lernen. Aber, und das ist der Grund für unsere heutige Folge, seit März dieses Jahres bricht ein völlig neues System namens Hermes diese eiserne Regel auf geradezu provokante Weise. Und wie das das tut. Wir schauen uns heute also diesen Hermes-Agenten an, der sich in nur wenigen Wochen als eine extrem solide, ja ich würde fast schon sagen revolutionäre Basis für Agentensysteme etabliert hat. Ja, das ging wirklich rasend schnell. Absolut. Und das Faszinierendste daran ist, dieser eine Widerspruch, den wir heute mal komplett entwirren wollen. Hermes gibt sich nach außen hin über eine völlig standardisierte Programmierschnittstelle exakt wie ein gewöhnliches Sprachmodell aus. Aber im Hintergrund, tief im Verborgenen sozusagen, da lernt dieser Agent tatsächlich kontinuierlich aus seinen Erfahrungen. Und genau das ist das architektonische Meisterstück, das wir heute im Detail auseinandernehmen wollen. Wir wollen wirklich mal auf die mechanische Ebene gehen und verstehen, wie dieser Agent unsere theoretischen Entwicklungsstufen so in die reale Praxis umsetzt. Weil das ja bisher immer eher Theorie war, oder? Richtig, genau. Denn das, was Hermes da tut, also sich als etwas total Simples auszugeben, während im Hintergrund eine hochkomplexe Maschine rattert, das löst einfach mal eines der größten Probleme in unserer Branche. Okay, dann lassen wir uns doch direkt bei dieser perfekten Illusion ansetzen. Ich stelle mir das ungefähr so vor. Hermes zieht sich quasi ein Kostüm an und behauptet gegenüber meiner Software einfach so, ah, hallo, ich bin doch nur ein ganz normales, einfaches Sprachmodell, schick mir einfach deinen Text. Ja, das ist ein schönes Bild. Was genau passiert denn in der Sekunde, in der ich als Nutzer in meiner Chat-Benutzeroberfläche eine Frage eintippe und, naja, auf Senden drücke? Also, der Prozess ist mechanisch wirklich faszinierend gelöst. Wenn deine Benutzeroberfläche diese Frage absendet, schickt sie diese an eine völlig standardisierte Programmierschnittstelle. Für deine Benutzeroberfläche, also das Chat-Fenster, das du da auf dem Bildschirm vor dir siehst, sieht das alles so aus, als würde sie einfach mit einem ganz gängigen Textgenerator kommunizieren. Also alles wie immer. Genau, alles wie immer. Aber, und jetzt kommt's, in der exakten Millisekunde, in der diese Anfrage bei Hermes auf dem Server ankommt, passiert dieser Magietrick. Es startet eben kein simples, äh, stochastisches Vervollständigen von Wortern. Sondern? Stattdessen wird die Anfrage quasi abgefangen und ein kompletter autonomer Agentenkreislauf wird initiiert. Das System hält kurz inne, analysiert deine Frage erstmal inhaltlich, überlegt sich dann einen mehrstufigen Plan, ruft verschiedene Werkzeuge auf, führt dann vielleicht völlig eigenständig drei oder vier Internetsuchen durch. Wahnsinn. Ja, oder es liest lokale Dateien aus, bewertet all diese Zwischenergebnisse kritisch und fasst dann erst all diese gesammelten Informationen in einer kohärenten Antwort zusammen. Weißt du, das erinnert mich total an einen Besuch in einem wirklich guten, sagen wir mal gehobenen Restaurant. Du kommst rein, sitzt entspannt an deinem Tisch und bestellst bei deinem Kellner. Und in unserer Analogie ist dieser Kellner jetzt das simple Sprachmodell. Oh, das ist ein super Vergleich, ja? Du sagst ihm halt, was du willst und erwartest, dass der dir wenig später den fertigen Teller bringt. Was du vom Gastraum aus aber absolut nicht mitbekommst, ist das gewaltige, perfekt orchestrierte Chaos da hinten in der Küche. Da brennt die Hütte quasi. Genau. Da steht dein Agent, da wird gebraten, da ruft der Chefkoch seine Kommandos, da werden Soßen reduziert und frische Zutaten aus dem Kühlhaus geholt. Und wenn das Meisterwerk dann vollbracht ist, wischt sich der Kellner die Hände ab, tritt völlig entspannt durch die Schwingtür und serviert dir lächelnd dein Essen. Du siehst nur das finale Resultat. Und du hast keine Ahnung von der harten Arbeit dahinter. Alle Zwischenschritte, alle, naja, auch alle verbrannten Versuche in der Küche, die bleiben vor dir einfach verborgen. Richtig. Aber jetzt mal provokant gefragt. Warum betreibt man dieses gewaltige Versteckspiel architektonisch überhaupt? Das muss doch wahnsinnig aufwendig sein. Naja, die Antwort darauf lautet eigentlich schlicht und ergreifend nahtlose Rückwärtskompatibilität. Wie meinst du das genau? Warum ist das so viel besser, als dem Nutzer einfach direkt zu zeigen, was der Agent gerade alles so treibt? Stell dir mal vor, wie viele Systeme, Unternehmenssoftware, Handyapplikationen und Chatprogramme es da draußen auf der Welt bereits gibt. Die wurden alle in den letzten zwei Jahren darauf programmiert, Stumpftext an ein Sprachmodell zu schicken und Stumpftext zurückzu erwarten. Okay, das sind wahrscheinlich Millionen von Anwendungen. Genau. Und wenn du all diesen Tausenden oder Millionen von Systemen nun plötzlich beibringen müsstest, mit einem echten, komplexen Agenten zu kommunizieren, also einem System, das plötzlich Rückfragen stellt, das meldet, ich starte jetzt eine Websuche oder ich lade jetzt ein Dokument, dann müsstest du unzählige Zahlen Code umschreiben. Ah, verstehe. Die würden wahrscheinlich einfach abstürzen, oder? Absolut. Die Benutzeroberflächen würden crashen, weil sie diese komplexen Statusmeldungen gar nicht verstehen können. Aber durch diese Hermes-Architektur kann jedes bestehende System plötzlich die gigantische Kraft eines hochkomplexen Agenten nutzen, ohne dass auch nur eine einzige Zeile Code in der ursprünglichen App geändert werden muss. Das ist eigentlich genial. Ja, du tauschst im Hintergrund einfach die Zieladresse der Programmierschnittstelle aus und zack, schon hast du ein massives Agent-Tits-Upgrade durchgeführt. Okay, wenn wir jetzt mal gedanklich durch diese Schwingtür in die Küche gehen, müssen wir definitiv über die Werkzeuge sprechen, die dem Chefkoch da zur Verfügung stehen. In unseren Entwicklungsstufen eines autonomen KI-Agenten ist die Integration von Werkzeugen ja ein massiver Sprung. Wie genau ist das denn bei Hermes gelöst? Also Hermes verfügt von Haus aus über mehr als 50 verschiedene Werkzeuge. 50? Das ist eine Menge. Ja, und das Spektrum ist riesig. Das reicht von sehr simplen Operationen wie dem einfachen Auslesen einer Textdatei über den vollen administrativen Zugriff auf ein Systemterminal bis hin zur feingranularen Steuerung eines kompletten Webbrowsers, um Webseiten visuell zu analysieren. Wahnsinn! Und der wahre Clou an der ganzen Sache ist die Architektur der Registrierung. Bei älteren Systemen hast du ja meistens eine gigantische monolithische Konfigurationsdatei. Wenn du da ein neues Werkzeug hinzufügen willst, musst du den kompletten Code anpassen, das Werkzeug registrieren, die Beschreibungen pflegen und dann das ganze System mühsam neu starten. Ja, das kenne ich. Das ist extrem nervig. Eben. Und Hermes macht das radikal anders. Die Werkzeuge sind modulare, eigenständige Dateien. Wenn du ein neues Werkzeug brauchst, wirfst du diese Datei einfach in den entsprechenden Ordner auf deiner Festplatte. Einfach per Drag & Drop sozusagen? Quasi, ja. Und beim nächsten Durchlauf erkennt das System die Datei automatisch, liest ihre Fähigkeiten aus und integriert sie völlig selbstständig in sein Repertoire. Warte mal, da muss ich direkt mal einhaken. Du sagst, der Agent hat Zugriff auf über 50 Werkzeuge gleichzeitig? Also aus meiner eigenen Erfahrung weiß ich, wenn ich einem handelsüblichen Modell auch nur drei oder vier verschiedene Werkzeuge in die Hand gebe, dann fängt das oft schon wild an zu halluzinieren. Ja, das klassische Problem. Genau. Es nutzt dann das Terminal, wenn es eigentlich den Browser nutzen sollte oder erfindet irgendwelche Parameter, die gar nicht existieren. Wie um Himmels Willen bricht Hermes bei 50 Werkzeugen nicht komplett unter seiner eigenen Komplexität zusammen? Das ist eine absolut berechtigte Frage und genau das Problem, an dem viele Entwickler regelmäßig verzweifeln. Die Lösung von Hermes liegt hier in einer extrem strikten Strukturierung der Systemanweisungen und in einer cleveren Vorfilterung. Das Modell bekommt nämlich nicht jeder Millisekunde alle 50 Werkzeuge einfach so unstrukturiert vor die Füße geworfen. Ah, okay. Das heißt, es wird portioniert. Ganz genau. Die Systemarchitektur gruppiert diese Werkzeuge logisch und gibt dem Sprachmodell extrem präzise Leitplanken, in welcher Phase der Problemlösung welche Kategorie von Werkzeugen überhaupt Sinn ergibt. Zudem lernt das System durch sein Gedächtnis, welche Werkzeuge bei dir als Nutzer in der Vergangenheit die besten Ergebnisse geliefert haben. Womit wir beim vielleicht wichtigsten Punkt heute wären? Dem Gedächtnis. Wir haben ja ganz am Anfang diesen großen Widerspruch aufgemacht, dass dieses System eben nicht vergisst. Wie funktioniert dieses Lernen denn auf einer rein technischen Ebene? Also Hermes nutzte ein Konzept, das auf drei unterschiedlichen Ebenen des Gedächtnisses aufbaut. Für unsere Betrachtung heute ist eigentlich die spannendste Ebene das sogenannte kuratierte Gedächtnis. Okay, kuratiert heißt was genau in dem Kontext? Naja, stell dir das bitte nicht wie eine simple Chat-Historie vor, in der einfach Wort für Wort alles stumpf mitgeschrieben wird. Stattdessen beobachtet der Agent im Hintergrund ganz stillschweigend den Verlauf eurer Unterhaltung. Wenn er dann eine wichtige Erkenntnis über dich gewinnt, also zum Beispiel, dass du Programmiercode immer in einer ganz bestimmten Sprache bevorzugst oder Antworten von ihm lieber extrem kurz hast, dann schreibt er sich selbstständig strukturierte Notizen. Aha. Und jetzt kommt der mechanische Trick, der das Ganze wirklich effizient macht. Beim Start jeder völlig neuen Sitzung wird ein quasi eingefrorener Schnappschuss dieses gesammelten Gedächtnisses genommen und hart in die grundlegende Verhaltensanweisung des Systems, also den System-Prompt geladen. Moment, Moment. Auch hier muss ich wieder kritisch nachfragen. Du sagst, beim Start wird ein eingefrorener Schnappschuss geladen. Das klingt für mich ehrlicherweise nach einem enormen Flaschenhals. Was ist denn, wenn ich mich gerade eine gute halbe Stunde richtig tiefgründig mit dem Agenten unterhalte und sich exakt während dieses Gesprächs meine Präferenzen komplett ändern? Okay. Ich verstehe, worauf du hinaus willst. Weil wenn der Schnappschuss eingefroren ist, greift das System dann nicht die ganze Zeit auf veraltete Daten zu und ignoriert meinen Sinneswandel völlig? Das ist ein sehr, sehr scharfer Einwand. Auf den ersten Blick wirkt das tatsächlich starr. Aber genau hier verbirgt sich eine der brillantesten Optimierungen dieser ganzen Architektur. Wir müssen hier kurz auf die Kosten und den Berechnungsaufwand eines Sprachmodells schauen. Die ja nicht gerade gering sind. Eben. Normalerweise müsste so ein Modell bei jeder neuen Frage, die du eintippst, die gesamte bisherige Unterhaltung inklusive aller Systemregeln von der allerersten Silbe an komplett neu lesen und mathematisch durchberechnen. Das kostet immens viel Rechenleistung. Und das Konzept, das Hermes hier nutzt, um das zu umgehen, nennt sich Prefix Caching. Prefix Caching. Okay, erklär das kurz. Dabei werden diese großen, gleichbleibenden Textbausteine des Gedächtnisses, also unser eingefrorener Schnappschuss, nur ein einziges Mal berechnet und dann im Zwischenspeicher, quasi direkt im Arbeitsspeicher der Grafikkarte, gehalten. Das spart massiv Zeit und vor allem Geld. Ah, verstehe. Er muss diesen dicken Regelwälzer also nicht jedes Mal wieder neu durchlesen, sondern hat ihn schon verinnerlicht. Aber was ist denn jetzt mit meinen neuen Vorlieben aus dem aktuellen Gespräch? Genau da kommt eine sehr saubere Trennung ins Spiel. Das Präfix Caching bedeutet ja nicht, dass der Agent vergesslich oder plötzlich unflexibel ist. Was der Agent in genau dieser Sekunde eurer aktuellen Unterhaltung lernt, das hält er ohnehin in seinem dynamischen Kurzzeitgedächtnis, also dem aktiven Kontextfenster, bereit, um dir sofort passend zu antworten. Okay, das ist also separat. Richtig. Und wenn er dabei eine wirklich fundamentale neue Regel lernt, dann schreibt er diese Erkenntnis sofort im Hintergrund auf die Festplatte. Er wendet diese neu geschriebene Regel für sein fundamentales Langzeitverhalten aber ganz bewusst erst an, wenn du eine völlig neue Sitzung startest. Das ist clever. Ja, weil das verhindert, dass der Agent so mitten im Fluss auf einmal seine komplette Persönlichkeit oder Arbeitsweise radikal ändert. Es ist eine extrem saubere Trennung zwischen tiefem Langzeitwissen und der hochdynamischen temporären Flexibilität eurer aktuellen Unterhaltung. Das ist wirklich extrem elegant gelöst und klärt eigentlich auch den Widerspruch aus dem Intro. Aber wenn wir von Anpassung sprechen, möchte ich gerne noch eine Stufe tiefer gehen. Wie genau bringt sich das System denn wirklich fundamental neue Dinge bei? Was genau stellst du dir darunter vor? Naja, wenn ich an echte Selbstverbesserung in der künstlichen Intelligenz denke, dann habe ich immer dieses Bild von Forschern im Kopf, die riesige Matrizen berechnen und neuronale Netze anpassen, Gewichte verändern und diese Modelle für Millionenbeträge völlig neu trainieren. Genau dieses Bild, das müssen wir bei Agenten wie Hermes jetzt komplett aus dem Kopf streichen. Hermes nutzt eine sogenannte Skill-Architektur, also eine Fähigkeitenstruktur, die auf einem völlig anderen Paradigma basiert. Wie sieht das aus? Wenn Hermes vor einer sehr komplexen, völlig neuen Aufgabe steht, sagen wir einfach mal, er soll ein extrem exotisches Dateiformat fehlerfrei konvertieren. Und er löst dieses Problem dann nach einigen Fehlversuchen erfolgreich durch den geschickten Einsatz seiner Werkzeuge, dann geht er eben nicht hin und versucht, seine internen neuronalen Gewichte anzupassen. Das wäre viel zu instabil und extrem fehleranfällig. Was macht er dann stattdessen? Er erstellt einfach völlig selbstständig eine strukturierte Textdatei, also eine sogenannte Markdown-Datei. Darin notiert er sich in völlig natürlicher Sprache die exakten Anweisungen, den logischen Pfad und die spezifischen Werkzeugaufrufe, die zu diesem Erfolg geführt haben. Warte, wenn ich das richtig verstehe, programmiert sich der Agent also nicht im klassischen Sinne selbst neu, sondern er schreibt sich quasi einfach einen sehr detaillierten Spickzettel für sich selbst? Ja, genau. Also so wie ein Handwerker, der nach einem echt komplizierten Auftrag einen Zettel an die Pinnwand in der Werkstatt hängt, auf dem dann steht, wenn nochmal so ein Auftrag reinkommt, nimm direkt den Zehnerschlüftel und ignoriere die rote Schraube. Besser kann man es wirklich nicht ausdrücken. Exakt so funktioniert das. Und die Tragweite dieser Mechanik ist für uns alle hier enorm wichtig zu verstehen. Wahre Selbstverbesserung in modernen intelligenten Systemen muss absolut nicht aus komplizierter Mathematik oder teure neuen Trainingsläufen bestehen. Es genügen rein deklarative Notizen. Das ist verrückt. Wenn Hermes bei einem späteren Neustart hochfährt, durchsucht er einfach seinen eigenen Fähigkeitsordner, findet diesen neu geschriebenen Spickzettel, liest ihn ein und erkennt ihn vollautomatisch als eine brandneue, festetablierte Fähigkeit. Der Agent hat sich selbst eine neue Fertigkeit beigebracht, schlichtweg, indem er seine hart erarbeitete Erfahrung in natürlicher Sprache aufgeschrieben hat. Weißt du, das fasziniert mich deshalb so sehr, weil es diese strukturelle Gefahr minimiert. Wenn du ein neuronales Netz umschreibst, läufst du ja immer Gefahr, dass das Modell plötzlich vergisst, wie man fehlerfrei Deutsch spricht, weil sich da intern irgendwelche Gewichte verschoben haben. Das sogenannte katastrophale Vergessen. Ja. Genau. Wenn Hermes aber einfach einen falschen Spickzettel schreibt, dann gehst du als Nutzer im schlimmsten Fall einfach in den Ordner auf der Festplatte und lüschst diese eine kleine Textdatei wieder. Das senkt die Barriere für das, was wir überhaupt als Lernen definieren, doch gewaltig. Völlig richtig. Es macht das Lernen transparent und vor allem jederzeit revidierbar. Lass uns den Blickwinkel nochmal ein bisschen weiten. Bisher klang das alles so, als würde ich die ganze Zeit vor einem Chatfenster sitzen und einfach auf Antworten warten, oder? Definitiv. Und Hermes ist architektonisch keineswegs darauf beschränkt, nur an einer einzigen Benucheroberfläche auf deinem Bildschirm zu existieren. Er ist auf 15 verschiedenen Kanälen gleichzeitig unterwegs. 15? Ja. Du kannst mit exakt demselben Kernagenten über deine diversen Messenger-Dienste kommunizieren. Du kannst ihm eine E-Mail schreiben oder du bindest ihn über eine Schnittstelle direkt in dein Smart Home ein. Das System, das die Entscheidungen trifft und auf das Gedächtnis zugreift, bleibt im Hintergrund immer exakt gleich. Nur die Ausgabekanäle sind extrem vielfältig. Das ist super praktisch. Aber was mich beim Studium der Funktionsweise wirklich komplett umgehauen hat, ist diese Proaktivität. Das System beherrscht ja die zeitgesteuerte Ausführung. Oh ja, das ist ein riesiges Feature. Für die technisch vielleicht nicht ganz so tief involvierten Hörer. Das bedeutet, ich richte sogenannte Cron-Jobs ein. Das sind Befehle, die nach einem festen Zeitplan im Hintergrund laufen. Ich muss den Agenten also gar nicht mehr aktiv ansprechen, damit er irgendetwas tut. Richtig. Du kannst Hermes anweisen, wache jeden Morgen um exakt 8 Uhr völlig autonom auf, nutze dein Browser-Werkzeug, durchsuche bestimmte Finanzportale nach ganz spezifischen Indikatoren, lade die Daten in dein lokales Gedächtnis und analysiere sie. Der Agent handelt in diesem Moment völlig losgelöst von irgendeiner menschlichen Eingabe. Und der Moment, wo diese Proaktivität für mich von nützlich zu absolut genial gewechselt ist, war dieses Konzept der Zustellungsrotung? Ja. Wenn dieser Agent morgens von sich aus aktiv wird und diesen komplexen Bericht erstellt, dann entscheidet er in genau diesem Moment auch völlig selbstständig, wohin dieses Ergebnis geschickt wird. Er ist ja an diese 15 Kanäle angebunden. Genau, er hat die freie Wahl. Er kann also analysieren, okay, diese Information ist heute extrem kritisch, ich schicke sie sofort über den Messenger direkt auf das Telefon meines Nutzers. Oder er sagt sich, naja, das sind nur Routinedaten, ich lege sie einfach stillschweigend in ein Archiv ab, ohne den Nutzer jetzt beim Frühstück zu stören. Diese Autonomie in der Verteilung der Informationen ist für mich eigentlich der Inbegriff eines echten Agenten. Und das bringt uns unweigerlich zu einem weiteren extrem mächtigen Baustein dieser ganzen Vernetzung. Hermes nutzt nämlich tiefgreifend MCMP. Ho, das ändert die Spielregeln natürlich nochmal komplett? Absolut. Der geniale Twist hierbei ist nämlich die Richtung der Kommunikation. Normalerweise kennen wir es ja so, dass ein Agent als Konsument auftritt, er nutzt externe Werkzeuge, um seine Aufgabe zu erfüllen. Aber Hermes stellt sich selbst als MCMP-Dienst für andere Systeme zur Verfügung. Er bietet sich quasi selbst an? Genau. Er bietet seine agentischen Fähigkeiten, sein Gedächtnis und all seine Werkzeuge nach außen an. Das dreht die klassische Architektur, die wir bisher in der Industrie kannten, wirklich völlig auf den Kopf. Wenn ich mir das jetzt alles mal am Stück anhöre, also ein System, das 50 Werkzeuge jongliert, das sich eigene Spickzettel schreibt, das sich über 15 Kanäle vernetzt und morgens von alleine aufwacht, dann drängt sich mir echt unweigerlich eine Frage auf. Was passiert, wenn wir mehrere von diesen hochpotenten Agenten zusammenschließen? Die Schwarmidee. Genau. Wenn ich einen Hauptagenten habe, der Aufgaben an spezialisierte Unteragenten delegiert, gibt es nicht sofort ein totales, unkontrollierbares Chaos, wenn jeder dieser kleinen Agenten anfängt, eigene Werkzeuge zu nutzen, eigene Textdateien zu schreiben und wild das Systemverhalten zu ändern? Diese Gefahr der Komplexitätsexplosion ist in Multiagentensystemen absolut real. Und das bringt ehrlich gesagt viele Projekte in der Praxis zum Scheitern. Aber die Architektur von Hermes löst dieses Problem durch eine bewusste, sehr harte Isolation. Wie sieht die aus? Es gibt ganz strenge Einschränkungen für untergeordnete Agenten. Wenn dein Hauptagent eine komplexe Teilaufgabe an einen spezialisierten Kindagenten delegiert, dann bekommt dieser Kindagent quasi elektronische Handschellen angelegt. Er darf zum Beispiel unter gar keinen Umständen diese Aufgabe an noch weitere Agenten delegieren. Ah, okay. Es gibt also keine endlose Kette von Unteraufträgen, die sich verselbstständigt. Richtig. Und noch viel wichtiger. Der untergeordnete Agent darf niemals direkt in das kuratierte Langzeitgedächtnis des Hauptsystems schreiben. Verstehe. Das ist also ungefähr so wie in einem großen Unternehmen. Du hast den Geschäftsführer, das ist unser Hauptagent. Der hat den vollen Zugriff auf die Firmenstrategie und die Akten. Wenn der Geschäftsführer jetzt einen hochspezialisierten externen Berater für eine spezifische Analyse einkauft, dann darf dieser Berater seine Aufgabe abarbeiten und brav den Bericht abgeben. Genau. Aber der Berater hat eben nicht die Befugnis, nachts heimlich die Firmenrichtlingen umzuschreiben oder eigenmächtig neue Abteilungen zu gründen. Das ist ein absolut perfekter Vergleich. Genau diese klaren, harten Grenzen verhindern das Chaos. Beschränkung und Isolation sind in der Welt der Multiagentensysteme paradoxerweise das absolute Schlüsselelement für Freiheit und Stabilität. Ohne diese strikten Leitplanken würde das System wahrscheinlich innerhalb von Stunden in sich zusammenfallen. Wir haben jetzt sehr viel über die Leistungen und die Fähigkeiten gesprochen. Das führt uns eigentlich zu einem Punkt, der in der Praxis oft das je Ende solcher Projekte bedeutet. Die Ressourcen. Oh ja, das Liebegeld. ...Kosten verschlingen. Wie um alles in der Welt stellt das System denn sicher, dass es wirtschaftlich überhaupt effizient bleibt? Hier betreten wir die hohe Kunst des intelligenten Rootings. Die Entwickler haben nämlich sehr schnell erkannt, dass nicht jede Frage gleich viel Intelligenz erfordert. Das System weiß, dass man nicht für jede triviale Aufgabe direkt das allergrößte, komplexeste und teuerste Sprachmodell anwerfen muss. Lass mich raten. Das System macht eine Art Triage, wie in der Notaufnahme eines Krankenhauses. Meinst du das? Naja, wenn ich mit einem kleinen Kratzer am Finger in die Klinik komme, dann brauche ich ja auch nicht den Chefarzt der Neurochirurgie, der in der Stunde Tausende von Euro kostet. Da reicht eine freundliche Pflegekraft, die mir ein Pflaster aufklebt, völlig aus. Erst wenn ich mit einem hochkomplexen Problem komme, wird der teure Spezialist aus dem Bett geklingelt. Exakt so arbeitet das intelligente Voting von Hermes. Wenn du eine kurze, simple Anfrage stellst, die beispielsweise aus weniger als 28 Wörtern besteht, etwa die Frage nach der aktuellen Uhrzeit oder eine ganz kurze Übersetzung, dann erkennt der Agent das sofort. Und reicht es weiter? Genau. Er leitet diese spezifische Anfrage blitzschnell an ein sehr kleines, extrem günstiges und reaktionsschnelles Modell weiter. Dieses Modell klebt dann quasi das Pflaster auf. Nur wenn die Aufgabe wirklich komplex ist, wenn tiefe logische Analyse, komplexe Programmierung oder langfristige Planung gefordert sind, erst dann werden die großen analytischen Schwergewichte hochgefahren. Das ergibt absolut Sinn. Aber wie geht das System denn mit der Last von endlos langen Unterhaltungen um? Wenn dieser Agent morgens von alleine aufwacht, den ganzen Tag Daten sammelt und ich abends noch stundenlang mit ihm diskutiere, dann fühlt sich doch unweigerlich das gesamte Kontextspeicherfenster immer weiter auf. Irgendwann platzt das System doch einfach aus allen Nähten. Auch hier greift wieder eine faszinierende Ressourcenintelligenz. Das System überwacht nämlich permanent den Füllstand seines eigenen Arbeitsgedächtnisses. Wenn das aktive Gesprächsfenster zu 85% mit Text gefüllt ist, schlägt das System intern Alarm. Und was passiert dann? Dann schaltet sich im Hintergrund, völlig unbemerkt von dir als Nutzer, wieder eines dieser kleinen, kostengünstigen Modelle ein. Seine einzige hochspezialisierte Aufgabe ist es dann, die weite Historie eurer bisherigen Unterhaltung zu lesen und extrem kompakt zusammenzufassen. Es räumt also auf. Richtig. Dieser komprimierte Text ersetzt dann die seitenlangen Protokonne im Speicher. Dadurch wird sofort wieder wertvoller Platz geschaffen, ohne dass der eigentliche große Hauptagent mit dieser trivialen Aufräumarbeit belastet wird oder wichtige Kontextinformationen aus der Vergangenheit verloren gehen. Wahnsinn. Lass uns das Ganze mal für dich als Hörer so richtig auf den Punkt bringen, warum das alles so unglaublich entscheidend ist. Wenn du in deinem Unternehmen oder auch für dich privat jemals vorhast, einen Agenten zu bauen oder zu nutzen, der rund um die Uhr sieben Tage die Woche betrieben wird, dann ist diese Effizienz keine nette, kleine, technische Spielerei. Absolut nicht. Das ist geschäftskritisch. Genau. Diese clevere Verteilung auf günstige Modelle für leichte Aufgaben und das automatische Komprimieren bei 85% Füllstand, das ist am Ende des Tages genau das, was über die finanzielle Machbarkeit und die tatsächlichen Betriebskosten deines gesamten Projekts entscheidet. Diese Mechanik macht buchstäblich den Unterschied zwischen einem unbezahlbaren theoretischen Laborexperiment und einem produktiven System, das wirklich draußen in der echten Welt skalieren kann. Dem kann ich nur absolut zustimmen. Eine revolutionäre Technologie ist halt immer nur dann wirklich revolutionär, wenn sie auch ökonomisch in der harten Realität bestehen kann. Und hier zeigt Hermes einfach auf sehr beeindruckende Weise, dass es nicht nur kognitiv leistungsfähig, sondern auch strukturell und wirtschaftlich extrem ausgereift ist. Tja, und damit sind wir auch schon am Ende unseres tiefen Tauchgangs in die wirklich faszinierende Mechanik des Hermes-Agenten angekommen. Wir hoffen, wir konnten dir einen greifbaren Einblick geben, wie die Zukunft der autonomen Systeme im Hintergrund bereits gebaut wird. Ja, es bleibt eine unglaublich spannende Zeit. Definitiv. Im Namen der gesamten KI-Gilde danken wir dir fürs Zuhören und verabschieden uns für heute von dir. Aber, und das ist mir noch wichtig, wir möchten dich nach all diesen technischen Tiefen einblicken nicht entlassen, ohne dir noch einen finalen, vielleicht leicht provokanten Gedanken mit auf den Weg zu geben. Da bin ich jetzt mal gespannt. Denk heute Abend einfach noch einmal an unser Bild von dem eleganten Restaurant und dem verborgenen Chaos in der Küche. Eine sehr gute Frage. Oder ob du nicht vielleicht schon längst einem völlig autonomen Agenten gegenüber sitzt, der, während du noch ganz gespannt auf seine Antwort wartest, bereits völlig selbstständig das halbe Internet durchsucht und tiefgehende Analysen über dich angefertigt hat. Denk da mal drüber nach. Bis zum nächsten Mal.