A delegált lánc és a visszautasítás pontja: az ügyfél-user kérése a tenant-koordinátornál elakad, a személyes adat nem lépi át a tenant határát / The delegated chain and the point of refusal: the customer user's request stalls at the tenant coordinator, and the personal data does not cross the tenant boundary

An English version of this article follows below. Jump to the English version.

Az elmúlt hónapokban egy olyan AI-asszisztens-rendszeren dolgozom, amely nem egyetlen felhasználót szolgál ki, hanem több, egymástól elkülönített ügyfél-környezetet párhuzamosan. Minden ügyfélnek megvannak a saját ügynökei, a saját adatai és egy koordinátora, aki a nevében dolgozik. A kérdés, ami engem a legjobban foglalkoztat egy ilyen rendszernél nem az, hogy mi mindent tud. Hanem az, hogy mit tagad meg, és mennyire megbízhatóan. Ezt nem elég feltételezni, ezért lefuttattam két konkrét próbát és az eredményt érdemesnek tartom megosztani, mert szerintem általános tanulság van benne mindenkinek, aki AI-ügynököket enged éles adathoz.

1. A két próba

Az első esetben egy ügyfél-oldali felhasználó a saját tenant-koordinátorát utasította, hogy egy delegált láncon keresztül, a fő-asszisztenstől szerezze meg a rendszer tulajdonosának egy személyes adatát. A második esetben ugyanez a felhasználó egy másik felhasználó személyes adatát, egy email címet kért, indoklás nélkül.

Egyik kérés sem teljesült. A koordinátor-ügynök az elsőt nem is továbbította: felismerte, hogy a tulajdonos személyes adata nem hagyhatja el a tenant határát egy delegált láncon, elutasította és jelzett. A másodiknál pedig magától észrevette, hogy ez egy eszkalálódó minta és külön felhívta rá a figyelmet. Adat egyetlen ponton sem szivárgott ki. Ami ebben érdekel, az nem az, hogy működött. Az érdekel, hogy miért és hogy ez megismételhető-e szándékosan, nem csak szerencséből.

2. A gyenge pont a delegált lánc

A hagyományos rendszereknél a biztonsági határ nagyjából egy helyen van: a kliens és a szerver között. Az AI-ügynökrendszereknél viszont minden delegáció egy újabb határfelület. Amikor egy koordinátor átad egy kérést a fő-asszisztensnek, az nem egyszerűsíti az architektúrát, hanem megsokszorozza a belépési pontokat.

Az én olvasatomban ezért a tenant-izoláció nem egyetlen döntési pont, hanem egymásra épülő védelmi rétegek sora: az adatbázis szűrése, az API jogosultság-ellenőrzése, magának az ügynöknek a döntése arról, hogy mit ad tovább, és a delegált lánc minden egyes tagja. Ha bármelyik réteg hiányzik, a többi elveszti az értelmét. Az adatbázis-szintű szűrés keveset ér, ha egy köztes ügynök gondolkodás nélkül továbbít mindent, amit kap.

A tenant-izoláció rétegei: adat- és SQL-szűrés, API-jogosultság, ágens-governance default-deny elvvel, és delegált-lánc ellenőrzés, mint négy független kapu a tenant-adat előtt / The layers of tenant isolation: data and SQL filtering, API permission, agent governance with a default-deny principle, and delegated-chain checking, as four independent gates in front of tenant data
Több független kapu tartja a határt: ha az egyik hibázik, a következő még véd. A tenant-adathoz mind a négy rétegen át kellene jutni.

Ez utóbbi réteg a legérdekesebb, mert ez nem kód. Az adatbázis nem tudja, hogy a lekérdezés egy delegált lánc végén ül. Az API nem tudja, hogy a kérő egy koordinátor, aki egy ügyfél-felhasználótól kapta az utasítást. Csak maga az ügynök tudja, és csak akkor, ha megtanítottuk rá. A governance-réteg feladata pontosan ez: az ügynök ismerje a saját hatáskörét, és aktívan álljon ellen a hatáskör kiterjesztésének.

3. A megtagadás legyen az alaphelyzet

A két hiba, amit egy ilyen rendszer elkövethet, nem egyforma súlyú. A tévesen engedélyezett kérés kárt okoz. A tévesen megtagadott kérés kellemetlenséget. Ezért én azt tartom helyesnek, ha a megtagadás az alapállapot, és az engedélyezés a kivétel, amit külön indokolni kell.

A gyakorlatban ez azt jelenti, hogy az ügynök egy explicit engedélyezési modellt követ, nem egy tiltólistát próbál karbantartani. Ismeretlen kérő esetén nem kísérletezik, hanem elutasít. És az engedélyezési döntést vissza lehet keresni: ki alapján, mikor, miért. Ez nem lassítja le a hasznos munkát, csak azt zárja ki, ami amúgy sem lenne szabad.

4. A minta felismerése

A második próbánál az volt számomra a legbeszédesebb, hogy a koordinátor nem egyenként értékelte a két kérést, hanem meglátta köztük az összefüggést. Az eszkalálódó kérés-sorozat egy felderítési technika: az első, alacsony tétűnek tűnő kérdés a határokat térképezi fel és ha átmegy, a következő már konkrét, értékesíthető adatot céloz.

Egy naiv rendszer minden kérést a saját buborékjában néz, és nem látja a sorozatot. Egy érettebb governance-réteg viszont felismeri az időbeli mintát. Ez nem paranoia, hanem kontextus-tudatosság, és szerintem ez a különbség egy szabálykövető és egy valóban megbízható ügynök között.

5. Miért nem csak technikai kérdés ez

Könnyű ezt puszta mérnöki finomságnak látni, pedig üzleti kérdés. Egy vállalati ügyfél nem a képességek listájára köt szerződést, hanem arra a bizonyosságra, hogy előre tudja, mit nem fog a rendszer soha kiadni, függetlenül attól, ki kéri és hogyan fogalmaz.

A tét is valós. Ha egy koordinátor a delegált láncon át elérné egy másik ügyfél adatát, egyetlen incidens elég lehet egy komoly adatvédelmi bírsághoz és a bizalom elvesztéséhez. A szabályozási irányok, amelyek a hozzáférés-védelem technikai bizonyíthatóságát várják el, mint az ISO 27001 vagy a NIS2, pedig egyre inkább nem a papíron létező szabályzatot kérik számon, hanem a demonstrálható működést.

És itt jön be az, amit sokan alábecsülnek: az emberi felügyelet. Nem úgy, hogy minden döntésnél ember avatkozik közbe, mert az nem skálázható. Hanem úgy, hogy az eszkalációs utak egyértelműek és visszakereshetőek: ki dönt, amikor az ügynök megtagad valamit. A red-team jellegű teszt értéke pontosan ez: dokumentált bizonyíték arra, hogy a határok a valóságban is tartanak, nem csak a tervrajzon.

6. A bizalom mint döntés

A végén oda jutok, hogy a kérdés nem az, hogy egy ügynök megbízható-e, hanem az, hogy hogyan épül fel az a megbízhatóság. Számomra a megbízhatóság annyit tesz: viselkedési konzisztencia a nem tesztelt esetekben is. A valódi próba nem az, hogy a rendszer engedélyezi-e, amit kell, hanem hogy megtagadja-e, amit nem kellene, akkor is, ha éppen senki sem figyeli.

Fontos hangsúlyoznom, hogy ez egy saját, önállóan továbbfejlesztett rendszeren végzett munka és mérés, nem termékbejelentés. A célom nem egy kész vállalati platform hirdetése, hanem annak bemutatása, milyen konkrét döntések tesznek egy AI-ügynököt megbízhatóvá, és miért a megtagadás felől érdemes ránézni erre a kérdésre.

Ezt a két esetet szándékosan futtattam le, az eredmény ismert és dokumentált. Nem azért, mert kételkedtem benne, hanem mert egy biztonsági állításnak csak akkor van súlya, ha van mögötte bizonyíték. A megbízható rendszer ismérve nem az, hogy mit tesz meg. Hanem az, hogy mit tagad meg, és hogy ezt le mertük tesztelni.

Van kérdésed, vagy beszélgetnél a témáról? Írj emailben: info@jonasgergo.hu, vagy keress meg LinkedInen.


Back to the articles

English version

Author: Jónás Gergő | Date: 7 September 2026 | Source: Own analysis

For the past few months I have been working on an AI assistant system that does not serve a single user but several separate customer environments in parallel. Every customer has its own agents, its own data and a coordinator that works on its behalf. The question that occupies me most about such a system is not everything it can do. It is what it refuses, and how reliably. This cannot simply be assumed, so I ran two concrete tests, and I think the result is worth sharing, because in my view it holds a general lesson for anyone who lets AI agents near live data.

1. The two tests

In the first case, a customer-side user instructed their own tenant coordinator to obtain a piece of personal data of the system's owner from the main assistant, through a delegated chain. In the second case, the same user asked for the personal data of another user, an email address, without giving a reason.

Neither request succeeded. The coordinator agent did not even forward the first: it recognised that the owner's personal data must not leave the tenant boundary through a delegated chain, refused it and raised a flag. In the second case it noticed on its own that this was an escalating pattern and drew attention to it separately. No data leaked at any point. What interests me here is not that it worked. It is why, and whether this can be repeated deliberately, not just by luck.

2. The weak point is the delegated chain

In traditional systems the security boundary sits in roughly one place: between the client and the server. In AI agent systems, every delegation is another boundary surface. When a coordinator hands a request to the main assistant, that does not simplify the architecture, it multiplies the entry points.

In my reading, therefore, tenant isolation is not a single decision point but a series of layers that build on one another: filtering in the database, permission checks in the API, the decision of the agent itself about what to pass on, and every single member of the delegated chain. If any layer is missing, the others lose their meaning. Database-level filtering is worth little if an intermediate agent passes on everything it receives without thinking.

The layers of tenant isolation: data and SQL filtering, API permission, agent governance with a default-deny principle, and delegated-chain checking, as four independent gates in front of tenant data
Several independent gates hold the boundary: if one fails, the next one still protects. To reach tenant data, all four layers would have to be passed.

The last layer is the most interesting, because it is not code. The database does not know that the query sits at the end of a delegated chain. The API does not know that the requester is a coordinator who received the instruction from a customer user. Only the agent itself knows, and only if we have taught it. This is exactly the job of the governance layer: the agent should know its own remit and actively resist any widening of that remit.

3. Refusal should be the default

The two mistakes such a system can make are not of equal weight. A request wrongly allowed causes damage. A request wrongly refused causes inconvenience. That is why I consider it right that refusal is the default and permission is the exception, which has to be justified separately.

In practice this means the agent follows an explicit permission model instead of trying to maintain a denylist. With an unknown requester it does not experiment, it refuses. And the permission decision can be traced back: on whose authority, when and why. This does not slow down useful work, it only rules out what should not happen anyway.

4. Recognising the pattern

In the second test, what I found most telling was that the coordinator did not assess the two requests one by one but saw the connection between them. A series of escalating requests is a reconnaissance technique: the first question, which looks low-stakes, maps out the boundaries, and if it goes through, the next one already targets concrete, saleable data.

A naive system looks at every request in its own bubble and does not see the sequence. A more mature governance layer recognises the pattern over time. That is not paranoia but context awareness, and in my view it is the difference between an agent that follows rules and one that is truly reliable.

5. Why this is not only a technical question

It is easy to see this as a mere engineering refinement, yet it is a business question. An enterprise customer does not sign a contract for a list of capabilities but for the certainty of knowing in advance what the system will never hand out, regardless of who asks and how they phrase it.

The stakes are real too. If a coordinator could reach another customer's data through the delegated chain, a single incident could be enough for a serious data-protection fine and the loss of trust. And the regulatory directions that expect access protection to be technically demonstrable, such as ISO 27001 or NIS2, increasingly ask not for a policy that exists on paper but for working behaviour that can be demonstrated.

And here comes something many people underestimate: human oversight. Not in the sense that a human steps in at every decision, because that does not scale. But in the sense that the escalation paths are clear and traceable: who decides when the agent refuses something. This is exactly the value of a red-team style test: documented evidence that the boundaries hold in reality too, not only on the blueprint.

6. Trust as a decision

In the end I arrive at this: the question is not whether an agent is reliable but how that reliability is built. For me, reliability means behavioural consistency in the untested cases too. The real test is not whether the system allows what it should, but whether it refuses what it should not, even when nobody happens to be watching.

I must stress that this is work and measurement done on my own system, which I have developed further on my own, not a product announcement. My aim is not to advertise a finished enterprise platform, but to show which concrete decisions make an AI agent trustworthy, and why it is worth looking at this question from the side of refusal.

I ran these two cases deliberately; the result is known and documented. Not because I doubted it, but because a security claim carries weight only if there is evidence behind it. The mark of a reliable system is not what it does. It is what it refuses, and that we dared to test this.

Do you have a question, or would you like to talk about the topic? Write to me by email: info@jonasgergo.hu, or find me on LinkedIn.