Amikor a szabály tervez
nem újabb ellenőrzőlista, hanem három döntés, amelyet egy szabály kényszerített ki
not another checklist but three decisions that a rule forced
Röviden, előismeret nélkül. Az uniós MI-rendelet, a hálózati és információs rendszerek biztonságáról szóló NIS2 irányelv és az általános adatvédelmi rendelet (GDPR) elsőre ellenőrzőlistának látszik: pipálni kell, és kész. Én ezt a hozzáállást fordítva próbáltam ki: ha egy szabály ma bekerülne a rendszerembe, mit kellene másképp tervezni? Három ilyen döntést mutatok meg: az emberi felügyeletet, a hiba esetén tiltást és a törlést. Mindegyiknél leírom, mit változtatott, mibe kerül, és mi marad nyitva. Ez nem jogi tanács és nem megfelelőségi nyilatkozat: amit a jogról mondok, az az én olvasatom, a rendszerről mondottakat pedig a forráskódból és a futó beállításokból ellenőriztem. A rész a korábbiak nélkül is érthető.
An English version of this article follows below. Jump to the English version.
„Nem a törvényt akartam lemásolni, hanem azt kérdeztem: ha egy szabály ma bekerülne a rendszerembe, mit kellene másképp tervezni?”
A sorozat kérdése változatlan: mit ad egy kisvállalkozásnak vagy egy nagyobb cégnek az, hogy az eredeti személyes asszisztenst a saját rendszeremmé fejlesztettem tovább? A szabályozás terén a válasz nem egy tanúsítvány, hanem három tervezési döntés, mindegyik a hibáival együtt. A 8. pontban leírom azt is, mi az, amire ma nincs válaszom.
1. Mire használom a rendszert, és miért számít ez
Egy kérdéssel kezdem, mert minden más erre épül: mire használom a rendszeremet? Ma a saját mindennapi munkámra: levelekre, naptárra, feladatokra, dokumentumokra. Nem szűrök vele jelentkezőket, nem értékelem vele senki hitelképességét, és senkiről nem hozok vele döntést.
Ez azért fontos, mert az MI-rendelet olvasatomban nem azt kérdezi, milyen szoftver ez, hanem azt, hogy mire használják. A szigorúbb, úgynevezett magas kockázatú kategóriába az a rendszer esik, amelyet a rendelet egyik mellékletében (a III. mellékletben) felsorolt területek valamelyikén használnak. Ilyen terület például a foglalkoztatás, vagyis a jelentkezők szűrése vagy a munkavállalók teljesítményének figyelése, és ilyen a hitelképesség értékelése is (6. cikk (2) bekezdés). Ugyanaz a program tehát az egyik területen szigorúbb szabály alá esik, a másikon nem.
Két kiegészítés. Ha a rendszer csak szűk, előkészítő feladatot végez, és nem befolyásolja érdemben a döntés kimenetelét, akkor nem kell magas kockázatúnak tekinteni. Ha viszont természetes személyeket profilozik, az mindig magas kockázatú (6. cikk (3) bekezdés).
Ezért nem mondom azt, hogy a rendszerem megfelel az MI-rendeletnek, és azt sem, hogy nem tartozik alá. Ez attól függ, hogy ki hol és mire használja, és formális besorolást én nem végeztem.
A szerep is számít. A rendelet másként kezeli azt, aki a rendszert fejleszti, és a saját nevén forgalomba hozza vagy üzembe helyezi (szolgáltató, 3. cikk 3. pont), és azt, aki a saját hatáskörében használja (telepítő, 3. cikk 4. pont; a személyes, nem szakmai használat kivétel). Magamnak én mindkettő vagyok. Ha egy cég a rendszeremet használná, a cég lenne a telepítő, és bizonyos esetekben a szolgáltató szerepe is rá hárulhat. Ezt a határt nem én húzom meg, de a három döntés-kártyát ennek tudatában terveztem.
2. Első döntés: emberi felügyelet
A probléma. Egy ügynök (az a program, amely a nevemben dolgozik, eszközöket hív és üzeneteket küld) addig hasznos, amíg valaki ellenőrizni tudja, mit csinál. Ha minden lépést jóvá kellene hagynom, nem lenne értelme; ha semmit, nem merném rábízni.
A szabály. Az MI-rendelet a magas kockázatú rendszereknél olyan tervezést vár, hogy személyek hatékonyan felügyelhessék a rendszert használat közben (14. cikk), és azt is, hogy a rendszer az eseményeket a működés teljes időtartama alatt automatikusan naplózza (12. cikk). A felügyelő a 14. cikk (4) bekezdése szerint képes kell legyen megérteni a rendszer képességeit és korlátait, tudatában lenni az automatizációs torzításnak, a kimenetet felülírni vagy mellőzni, és beavatkozni vagy biztonságosan leállítani a rendszert. A szolgáltató az általa kezelt naplókat legalább hat hónapig őrzi (19. cikk (1) bekezdés), az uniós adatvédelmi joggal összhangban. Ezek a hivatkozások másodlagos forrásból, kivonat-szinten ellenőrzöttek (lásd a cikk végén). Egy ügynök esetében az olvasatom az, hogy a felügyelet nem egy gomb a végén, hanem az önállóság beállítható mértéke, a megállítás lehetősége és a nyom, amelyet az ügynök hagy.
Amit terveztem. Az ügynökök minden műveletfajtához (kategóriához) egy önállósági szintet kapnak. Három szint van: csak jelez (az ügynök szól, de nem tesz semmit), javasol és jóváhagyást kér, és önálló (megteszi, majd jelent). A mai táblázatban 15 kategória van: 5 csak jelez szinten és ezen zárolva (törlés, külső üzenet küldése, fizetés, jogosultság-változtatás, tartalom közzététele), 9 jóváhagyásos, 1 önálló. Ez a 2026. november 10-i állapot, a futó rendszer felületéről olvasva, és megegyezik a gyári alapbeállítással. A zárolt szintet a felület nem engedi feljebb emelni.
A jóváhagyási kérelemnek lejárata van. A gyári alapérték 60 perc minden olyan kategórián, amelyen jóváhagyás kérhető (a gyári táblázatban tíz ilyen van); az éles érték kategóriánként szerkeszthető, és ezt az élő értéket ebben a cikkben nem állítom. Ha a lejárat elérkezik, a kérelem „lejárt” állapotba kerül, és attól kezdve már nem lehet jóváhagyni vagy elutasítani, még akkor sem, ha a lejáratot kezelő perces ellenőrzés még nem futott le. A lejárat naplózódik, de összesítve: egy napló-sor rögzíti, hány kérelem járt le, a kérelem saját sora pedig lejárt állapotban megmarad. Egyenként külön eseményként a lejáratot ma nem naplózom, és ezt azért írom le, mert a tervem eredetileg ezt ígérte.
Mibe kerül. Lassabb, és több a kézi lépés. Egy jóváhagyásra váró művelet addig áll, amíg valaki nem néz rá, vagy a lejárat el nem dönti helyette.
Mi marad nyitva, és ez a legfontosabb rész.
- A szint a kódban adat, és az ügynök a saját utasításai szerint tartja be. A rendszer nem tilt meg fizikailag egy műveletet pusztán azért, mert a kategória „csak jelez” szinten áll. Kikényszerített, kódban rögzített kapu az e-mail-küldésre van. Aki azt olvassa, hogy „jóváhagyás nélkül nem cselekszik”, annak ezt tudnia kell: ez a mondat ebben a formában nem igaz.
- Az e-mail-küldés jóváhagyását csak a felületre bejelentkezett tulajdonos döntheti el, hozzáférési kulccsal (tokennel) nem. Ez a szabály a kódban alapértelmezetten ki van kapcsolva; nálam be van kapcsolva (2026. november 10-én megerősítettem), de aki a rendszeremet telepíti, annak ezt külön be kell kapcsolnia.
- A szintváltások naplózását nem találtam teljesnek: a lejárat és a tulajdonosi-döntés beállítás változása naplózott, a szint megváltoztatása külön naplósorként nem.
- Formális kockázati besorolásom és technikai dokumentációm nincs.
3. Második döntés: hiba esetén tiltás
A probléma. A biztonsági ellenőrzés hibázhat: leállhat, időtúllépést kaphat, el sem indulhat. Ilyenkor két dolgot tehet a rendszer: átengedi a műveletet („hiba esetén engedő” működés), vagy megállítja („hiba esetén tiltó”, angolul fail-closed).
A szabály. A NIS2 az alapvető és fontos szervezeteknek megfelelő és arányos kockázatkezelési intézkedéseket ír elő, többek között az üzletmenet-folytonosság és az ellátási lánc biztonsága területén. A magyar átültetés, a 2024. évi LXIX. törvény 6. §-a ezt a szervezet vezetőjére teszi: kockázatmenedzsment keretrendszert kell létrehoznia és működtetnie (6. § (2) bekezdés), gondoskodnia kell az információs rendszer eseményeinek nyomon követhetőségéről (6. § (5) bekezdés c) pont), és időszakos értékelést is vár a védelmi intézkedésekről (6. § (3) bekezdés 10. pont). A törvényszöveg hatályállapota 2026. október 1. és december 31. között érvényes.
Miért érdekel engem, a szoftver készítőjét. A szabály az érintett szervezetre vonatkozik, nem rám. A törvény azonban azt is kimondja, hogy ha a szervezet közreműködőt vesz igénybe az információs rendszer létrehozásához, üzemeltetéséhez, karbantartásához, javításához vagy az adatkezeléshez, akkor gondoskodnia kell arról, hogy a közreműködő tevékenységéhez szükséges kiberbiztonsági követelmények szerződéses kötelemként teljesüljenek (6. § (5) bekezdés d) pont), és a vezető ezért akkor is felel (6. § (6) bekezdés). A követelmény tehát a beszállítói láncon keresztül, szerződésen, kérdőíven és audit-jogon át hozzám is megérkezik. Hogy a saját vállalkozásom közvetlenül is a törvény hatálya alá esne-e, azt nem vizsgáltam.
Amit terveztem: a kapuk. Először azt mondom el, mi az a kapu, mert ez a döntés erre épül. Egy ügynök nemcsak beszélget: lépéseket tesz. Parancsot futtat, weblapot kér le, fájlt olvas vagy ír, levelet küld. A kapu egy kis program, amely egy ilyen lépés előtt lefut, megnézi, mit akar az ügynök, és vagy átengedi, vagy megállítja. Ha megállítja, az ügynök egy magyarázatot kap vissza, és a lépés nem történik meg. Olyan, mint egy ellenőr az ajtóban: nem dolgozik helyettem, csak azt nézi, hogy a rossz lépés ne induljon el.
Milyen kapuk vannak. Ma 11 kapu-szkriptem van. A fajtáik hétköznapi nyelven:
- Levélküldés. A segédügynökök egyáltalán nem küldhetnek levelet. A fő ügynök levele csak akkor megy ki, ha egy ember pontosan erre a levélre igent mondott: a jóváhagyás a levél ujjlenyomatához (hash) kötődik, tehát ha a szöveg egyetlen betűvel változik, a jóváhagyás nem érvényes. A jóváhagyási kérés 60 perc alatt lejár, a megadott jóváhagyással pedig 30 percen belül el kell küldeni a levelet. Az igent csak én mondhatom ki, a felületre bejelentkezve; az ügynök a saját hozzáférési kulcsával a saját levelét nem hagyhatja jóvá. Egy külön kapu a levél szövegét is megnézi, mielőtt jóváhagyás fogyna rá (például az ékezet nélküli magyar szöveget visszadobja).
- Külső hálózat. Weblapot csak engedélyezett címről lehet lekérni (engedélylista), a többi külső tartalom egy elkülönített olvasón át jut az ügynökhöz, hogy ne utasításként érkezzen. Egy másik kapu a parancssorból induló hálózati kapcsolatot állítja meg.
- Veszélyes parancsok. A törlés, az áthelyezés, a rendszergazdai jog, a hitelesítő mappák és a
.envfájl (ahol a jelszavak vannak) érintése: ezeket a kapu megállítja. - Belépés és jogosultság. Ügynök nem hozhat létre belépést, munkamenetet vagy hozzáférési kulcsot, és a saját jóváhagyási kérését sem hagyhatja jóvá.
- A jóváhagyás aláírása. A jóváhagyásokat a szerver egy kulccsal írja alá. Ennek a kulcsnak az olvasását minden eszközön tiltja egy kapu, mert aki ezt olvassa, hamisítani tudna jóváhagyást. Ez nem „minden titok” kapuja, csak ezé az egy kulcsé; a jelszavak védelme a veszélyes parancsok kapuján át megy.
- Önállóság és korlátok. A segédügynök nem ütemezheti be önmagát, és nem írhatja a kapuk fájljait és a beállító fájlokat. Ez azért kell, hogy egy ügynök ne kapcsolhassa ki a saját korlátját.
- Elkülönítés és véletlen futás. Egy bérlő saját skilljét (az ügynök egy betanított képességét) csak az ő kérésében lehet használni, és egy parancsba bemásolt szöveg ne futhasson le véletlenül parancsként.
Egy példa a gyakorlatból. Ha egy ügynök a .env fájlt próbálja elolvasni, a veszélyes parancsok kapuja még a lépés előtt megáll: kiírja, hogy a fájl hitelesítő adatokat tartalmaz, és 2-es kilépési kóddal tilt. Az ügynök nem tudja megkerülni, csak jelezni tud nekem vagy a fő ügynöknek. Egy fontos határ: a kapuk a véletlen vagy lusta hibát fogják meg, nem az elszánt kerülőt, és több kapu a saját leírásában ezt ki is mondja.
Miért tilt a kapu, ha hibázik. Egy kapu is csak program, ezért el is romolhat: leállhat, időtúllépést kaphat, vagy el sem indulhat. Itt van a csapda. A Claude Code, amelyen az ügynökök futnak, csak a 2-es kilépési kódot olvassa tiltásnak. Minden más hibát úgy kezel, mintha nem történt volna semmi, és a műveletet átengedi. Egy elromlott kapu tehát alapból kinyitja az ajtót. Ezt fordítja át a kapu bejegyzésén álló beállítás (onFailure: block): ezzel a kapu hibája esetén a lépés megáll. Ezt a saját kárommal tanultam meg. 2026. november 1-jén élőben kipróbáltam az időtúllépést: a beállítással a hívás megállt, nélküle lefutott. Ezért a beállítás minden kapun kötelező, egy ellenőrzés hibaként jelzi, ha valahol hiányzik, és az indítás beírja a hiányzót. Két kapu ezen felül magát is leállítja 8 másodperc után, és ha a kilépési kódja se 0, se 2, maga alakítja 2-re, vagyis tilt. A veszélyes parancsok kapuja a saját hibájára is tiltással válaszol.
Mibe kerül. Több a téves riasztás és több a kézi jóváhagyás. A saját tapasztalatom: a kapu néha olvasó parancsokat is megállít, ha a parancs szövege egy védett fájl nevét tartalmazza. Ez a fail-closed ára, és a cikk anyagának összegyűjtése közben is előfordult.
Mi marad nyitva.
- A kapuk az ügynökök eszközhívásait védik. A programot, amellyel egy ügynök futhat, a gazdagép saját shelljétől a kapuk nem védik.
- Rendelkezésre állás és folytonosság: a rendszerem egy gépen, egy adatbázis-fájlon fut. A mentés éjszakai archívum, nem másodpéldány. Rendelkezésre állási vállalásom nincs. A NIS2 üzletmenet-folytonossági elvárására ma nincs jó válaszom, és a következő rész erről is szól.
- Incidens-jelentési lánc: nincs. A kapu-hibák és a riasztások belső értesítések, nem hatósági jelentések. A magyar szabály szerint az érintett szervezetnek az incidenst 24 órán belül először, 72 órán belül esemény-bejelentést kell tennie, a kezelés lezárása után egy hónapon belül pedig zárójelentést kell adnia (a 418/2024. Korm. rendelet 77. § (1) bekezdése szerint; a törvény 66. §-a csak annyit mond, hogy haladéktalanul, a kormányrendeletben foglaltak szerint). Egy ilyen láncot dokumentáltan még nem építettem meg.
4. Harmadik döntés: törlés és adatminimalizálás
A probléma. Az adat sorsa ott dől el, ahol a rendszer tervezésekor eldöntöm, mit tárol, mennyi ideig, és hogyan lehet kitörölni. A törlés nem egy gomb, hanem az is, hogy mit találok meg utána.
A szabály. A GDPR az adattakarékosságot (az adat a cél szempontjából megfelelő, releváns és a szükséges körre korlátozott, 5. cikk (1) bekezdés c) pont), a korlátozott tárolást (csak a cél eléréséhez szükséges ideig azonosítható formában, 5. cikk (1) bekezdés e) pont), a törlési jogot (17. cikk), a beépített és alapértelmezett adatvédelmet (25. cikk) és a kockázattal arányos biztonságot (32. cikk) írja elő. A hivatkozások másodlagos forrásból, kivonat-szinten ellenőrzöttek. A feszültség a törlés és a napló között van: a törlés azt várja, hogy ne maradjon nyom, az auditálhatóság azt, hogy maradjon. A 17. cikk (3) bekezdése olyan kivételeket sorol fel, amelyek mellett a törlés nem követelhető, köztük a jogi kötelezettség teljesítését és a jogi igények előterjesztését, érvényesítését vagy védelmét. Az én olvasatomban a naplónak és az auditnak az ilyen esetek lehetnek a legitim érvei; hogy egy konkrét nyom megtartása a gyakorlatban belefér-e ebbe, az nem az én döntésem.
Amit terveztem.
- Bérlő-törlés. A bérlő egy külön kezelt felhasználói szervezet, a bérlő-azonosító ezt jelöli. Törléskor egyetlen adatbázis-tranzakcióban, 16 lépésben törlődik a bérlő minden nyilvántartása: a jóváhagyások és naplójuk, az üzenetek, a feladattábla, a memória a keresőindexével együtt, az ütemezések, a skillek és fájljaik, a dokumentumok, a felhasználók, az eszköz-kulcsok, a csatorna-kötések és az SSH-kulcsok. Ha a törlés hibázik, az adatbázis-rész visszagördül.
- A titkok sorrendje. A titkok tárolója egy fájl, ezért a titkok törlése a tranzakció után történik. Ha ez elbukik, a bérlő sora már nincs meg, a titkok pedig megmaradnak, amíg a törlést meg nem ismétlem. A törlés ismételhető, és a hiba a hívónak is elmegy. „A titkok a törléssel együtt eltűnnek” tehát csak a sikeres titok-törlés után igaz.
- Mérés és napló. A bérlő törlése naplózott műveleti esemény, számokkal (hány memória, titok, ütemezés ment el). A telemetria és a naplók, amelyek bérlő-azonosítót hordoznak, szintén törlődnek.
- Megtartási tisztítás. Napi karbantartás törli a lejárt sorokat. Az alapértékek: az audit-táblák 90 nap, a jóváhagyási események 365 nap, a nyomvonal-szakaszok 30 nap, az üzenetnapló 90 nap; az éles beállítás ettől eltérhet. A tisztítás maga is naplózza magát (táblánkénti számokkal, a törléssel egy tranzakcióban): nincs törlés napló nélkül.
- Metaadat az audit-nyomban. A skillek változásának nyoma lenyomatot (hash) tárol, szöveget nem, mert egy skill bármit tartalmazhat, az audit-naplót pedig szélesebb kör olvassa. Ezt csak a skill-nyomra állítom; a többi audit-táblát ebből a szempontból nem vizsgáltam végig.
Szándékos döntés, nem hiány. A bérlő törlése után is megmarad három dolog: a hozzáférési kulcsok lenyomat-sora (visszavonva, csak lenyomattal), az ügynök-audit és a kapu-audit. Ezek azt őrzik, ki, mikor és mit módosított, és melyik kapu mit mondott. Úgy döntöttem, hogy a törlés a bérlő adatát viszi, a felelősségi nyomot nem. Ez egy tervezési ár: „teljes törlés mindenhonnan” nem igaz. Ugyanígy megmarad egy megosztott ügynök vagy egy bérlőhöz nem rendelhető sor.
Mibe kerül. Kevesebb nyom a hibakereséshez, mert amit törlök, azt később nem tudom megnézni.
Mi marad nyitva.
- A mentések: a törlés nem nyúl a mentésekhez. Egy törölt bérlő adata (és a titkai a hozzájuk tartozó mentett kulccsal) a már elkészült archívumokban marad, amíg a tisztítás ki nem tolja őket (alapból 30 archívumot őrzök). Azonnali, a mentésekre is kiterjedő törlést nem ígérek.
- Bérlő-adatkiviteli garancia nincs. Van egy export, amely az ügynökök csoportját viszi át egy másik telepítésre, de ez a csoport beállításait viszi át (önállósági szintek, modellbeállítás, ütemezések, kimenő-hálózati lista, jelszóval védett titkok), nem egy bérlő adatait. A bérlő-törlés útvonalán nincs „előbb exportáld” lépés.
- A bérlői elkülönítés alkalmazás-szintű (a lekérdezések szűrnek bérlő-azonosítóra, jogosultságkezelés van, és küldő-útvonal tábla), nem az adatbázis kényszeríti ki. Sor-szintű biztonság nincs; a rendszer ma egy SQLite-fájlra épül, a Postgres-hez az előkészítés megvan, de a Postgres éles használatban nincs.
5. Amit kóddal nem lehet megoldani
A három döntés-kártyán közös, hogy a kód csak egy része a válasznak. A szerződés a beszállítói láncban, a szerepkör és a felelősség kijelölése, az incidensek bejelentési folyamata, az időszakos független értékelés és a tanúsítás nem kódkérdés. Ezekből a rendszeremnek ma nincs független átvilágítása, nincs tanúsítványa, és az incidens-folyamatom dokumentálatlan.
Szabályolvasat-javaslat. Ha adatvédelmi vagy megfelelési területen dolgozol, nézd át a három döntés-kártyát, és írd meg, ha máshogy olvasod a szabályt. Erre a kódnál is nagyobb szükségem van.
6. Mikor mi kötelez: idővonal
A határidők közül azt jelölöm igazoltnak, amit elsődleges (hatályos) szövegen ellenőriztünk, és külön jelzem, mi másodlagos forrásból származik.
| Esemény | Mikor | Státusz |
|---|---|---|
| Magyar NIS2-átültetés, első bejelentés / esemény-bejelentés / zárójelentés | 24 óra / 72 óra / a kezelés után 1 hónap | Ellenőrizve (418/2024. Korm. rendelet 77. § (1), hatályállapot 2026. szeptember 11. - 2027. december 31.) |
| Kiberbiztonsági törvény következő hatályállapota | 2027. január 1. | Ellenőrizve (a jogtár jelzése), a tartalmát nem vizsgáltam |
| MI-rendelet, általános alkalmazás | 2026. augusztus 2. | Másodlagos forráson ellenőrizve (113. cikk) |
| Magas kockázatú, önálló rendszerek (III. melléklet, 6. cikk (2)) alkalmazása a módosított szöveg szerint | 2027. december 2. | Másodlagos forráson ellenőrizve: a 113., 12., 13., 14. és 19. cikk oldalai egybehangzók |
| Termékbe ágyazott magas kockázatú rendszerek (I. melléklet, 6. cikk (1)) a módosított szöveg szerint | 2028. augusztus 2. | Másodlagos forráson ellenőrizve, ugyanott |
Az MI-rendelet határidői egy halasztási módosítás miatt változtak, és a két dátumot, amelyet a táblázat a módosított szövegből ad meg, két nyilvános, harmadik fél által üzemeltetett, a szöveget követő oldal egybehangzóan közli. Az Official Journal szövegét ebben a cikkben nem olvastam, ezért ezeket „másodlagos forráson ellenőrzött” dátumként kezelem, és a halasztás rendeletszámát és kihirdetésének napját nem állítom. A 2030-as, nyilvános hatóságokra vonatkozó határidőt nem említem, mert nem tudtam ellenőrizni.
7. Számokban
Itt is csak azt mérem, ami ellenőrizhető, mindegyik mellé odaírom a módszert és a korlátját. A mérés ideje 2026. november 10.
- Autonómia-kategóriák: 15 (5 / 9 / 1). Mit mér: a futó rendszer felületén olvasott kategóriák száma szintenként (csak jelez, jóváhagyásos, önálló), és hogy ebből hány zárolt (5). Mit nem mér: azt, hogy az ügynök a szintet betartja; a szint az ügynöknek szóló utasítás, kivéve az e-mail-küldést.
- Kapu-szkriptek: 11. Mit mér: a kapuként működő szkriptek számát a forráskódban. A szám a szkriptek száma, nem a beállításbeli bejegyzéseké.
- Blokkoló CI-lépések: 28. Mit mér: a CI (az automatikus ellenőrzés, amely a változtatásokon lefut) két munkafolyamatának nevesített ellenőrző lépéseit, a beállító és feltöltő lépések nélkül: a fő munkafolyamatban 29 lépés van, ebből 26 blokkoló (3 csak jelent), a titok-ellenőrző munkafolyamatban további 2 blokkoló. „Blokkoló”: a lépés hibája elbuktatja a munkafolyamatot. Mit nem mér: azt, hogy a GitHub a változtatás beolvasztását is megtiltja-e egy elbukott lépés esetén; ez nem a kódban él, és nem állítom. A mérés a definíciók statikus leszámolása, nem futási statisztika.
- A teljes tesztcsomag pull requesten nem fut. A változtatásra a módosított fájlokat érintő tesztek futnak (az importgráf mentén), a teljes csomag a lefedettségi küszöbökkel csak a fő ágra pusholáskor. Ezért egy elbukó teszt a változtatást csak akkor fogja meg, ha a változtatás elér hozzá az importgráfon.
- Megtartás, alapértékek. Audit-táblák 90 nap, jóváhagyási események 365, nyomvonal-szakaszok 30, üzenetnapló 90; mentések: 30 archívum. Mit nem mér: az éles beállítást.
- Bérlő-törlés: 16 lépés egy tranzakcióban. Mit mér: a törlési lépések számát a kódban. Mit nem mér: a mentésekben megmaradt adatot.
8. Mit nem old meg ez
Előbb egy fontos kontextus. Amiről itt írok, az ma egy kis- és középvállalkozásoknak szánt termék, amely még fejlesztési fázisban van. Nem élő, üzemelő nagyvállalati környezetről beszélek. A lista ezért nem egy működő szolgáltatás hibalistája, hanem annak a leírása, hol tart a fejlesztés, és mit kell még megoldanom, mielőtt valaki éles üzemben használná.
Mit nem old meg ez. Nincs formális kockázati besorolásom és technikai dokumentációm az MI-rendelet szerint. Nincs dokumentált incidens-jelentési láncom. Nincs rendelkezésre állási vállalásom és nincs másodpéldányom: egy gép, egy SQLite-fájl, éjszakai archívum. A bérlői elkülönítés ma alkalmazás-szintű, nem az adatbázis kényszeríti ki, és sor-szintű biztonság nincs bekapcsolva. Ez a következő nagy lépés, és már folyamatban van: az átállás előkészítése megtörtént (van aszinkron adatbázis-réteg, és a bérlő-azonosítók a táblákon a kódban vannak), a Postgres-adatbázis és a sor-szintű biztonság következik. A szint nem kód-szintű tiltás, kivéve az e-mail-küldést, és annak a tulajdonosi döntési szabálya a kódban alapból kikapcsolt (nálam be van kapcsolva). A bérlő-törlés a mentésekhez nem nyúl, és bérlő-adatkiviteli garancia nincs. Nincs külső SIEM-integráció (az OTLP-export nem az). Nincs független átvilágítás és nincs tanúsítvány. A jogi állítások az én olvasatom; formális jogi felülvizsgálat nem volt.
9. Ami következik
A sorozat kérdése az, mit ad egy kisvállalkozásnak vagy egy nagyobb cégnek ez a rendszer az eredetihez képest. A szabályozás terén a válasz három döntés, mindegyik a hibáival együtt: az önállóság beállítható és lejáratos, a hiba tilt, és a törlés tudatosan választ, mit visz és mit őriz meg.
A három kártya közül kettő ugyanoda vezet vissza. Az egyik: ha törölnöm kell, és bizonyítanom, hogy ott sincs semmi, mire támaszkodhatok: a kódom fegyelmére, vagy az adatbázisra? A másik: ha egy szabály folytonosságot vár el tőlem, mire támaszkodhatok: egyetlen gépre és egyetlen fájlra, vagy olyan tárolóra, amely több helyen is él? A kettő együtt azt jelenti, hogy a kód fegyelme mellett az alatta lévő tárolás képességeire is szükségem lesz. A következő rész erről szól: mit kíván a skálázás, az izoláció bizonyítása és a több helyen élő üzemeltetés.
English version
In brief, for readers with no background. The EU AI Act, the NIS2 Directive on the security of network and information systems, and the General Data Protection Regulation (GDPR) look at first like checklists: tick the boxes and you are done. I tried the opposite approach: if a rule were introduced into my system today, what would have to be designed differently? I show three such decisions: human oversight, failing closed, and deletion. For each one I write down what it changed, what it costs, and what remains open. This is not legal advice and not a statement of compliance: what I say about the law is my reading, and what I say about the system I checked against the source code and the running settings. This part can be read without the earlier ones.
“I did not want to copy the law. I asked: if a rule were introduced into my system today, what would have to be designed differently?”
The question of the series is unchanged: what does a small business or a larger company gain from the fact that I turned the original personal assistant into my own system, which I have developed further on my own? On regulation, the answer is not a certificate but three design decisions, each with its flaws. In section 8 I also write down what I have no answer to today.
1. What I use the system for, and why it matters
I start with one question, because everything else rests on it: what do I use my system for? Today, for my own everyday work: emails, calendar, tasks, documents. I do not use it to screen applicants, I do not use it to assess anyone’s creditworthiness, and I do not use it to make decisions about anyone.
This matters because, in my reading, the AI Act does not ask what kind of software something is, but what it is used for. The stricter, so-called high-risk category covers a system that is used in one of the areas listed in an annex to the regulation (Annex III). Such areas include, for example, employment, that is, screening applicants or monitoring the performance of workers, and also the assessment of creditworthiness (Article 6(2)). The same programme can therefore fall under a stricter rule in one area and not in another.
Two additions. If the system performs only a narrow, preparatory task and does not materially influence the outcome of a decision, it need not be treated as high-risk. If, however, it profiles natural persons, it is always high-risk (Article 6(3)).
This is why I do not say that my system complies with the AI Act, and I do not say that it falls outside it. That depends on who uses it, where and for what, and I have not carried out a formal classification.
The role matters as well. The regulation treats differently the one who develops the system and places it on the market or puts it into service under their own name (the provider, Article 3, point 3) and the one who uses it under their own authority (the deployer, Article 3, point 4; personal, non-professional use is an exception). For myself I am both. If a company used my system, the company would be the deployer, and in some cases the role of provider could fall on it too. I am not the one who draws that line, but I designed the three decision cards with it in mind.
2. First decision: human oversight
The problem. An agent (a programme that works on my behalf, calls tools and sends messages) is useful only as long as someone can check what it does. If I had to approve every step, there would be no point; if I approved nothing, I would not dare to trust it.
The rule. For high-risk systems, the AI Act expects a design that lets natural persons oversee the system effectively while it is in use (Article 14), and it also expects the system to log events automatically over its whole lifetime (Article 12). Under Article 14(4), the person overseeing must be able to understand the capabilities and limitations of the system, to remain aware of automation bias, to override or disregard the output, and to intervene or stop the system safely. The provider keeps the logs under its control for at least six months (Article 19(1)), in line with EU data protection law. These references are verified on a secondary source, at the level of extracts (see the end of the article). For an agent, my reading is that oversight is not a button at the end: it is an adjustable degree of autonomy, the ability to stop, and the trail the agent leaves behind.
What I designed. Agents get an autonomy level for every kind of action (category). There are three levels: notify only (the agent says something but does nothing), propose and ask for approval, and autonomous (it acts, then reports). In today’s table there are 15 categories: 5 at notify only and locked there (deletion, sending an external message, payment, changing permissions, publishing content), 9 requiring approval, and 1 autonomous. This is the state as of 10 November 2026, read from the interface of the running system, and it matches the factory default. The interface does not allow a locked level to be raised.
An approval request has an expiry. The factory default is 60 minutes for every category on which approval can be requested (there are ten such categories in the factory table); the live value can be edited per category, and I make no claim in this article about the live value. When the expiry is reached, the request goes into the “expired” state and from then on it can no longer be approved or rejected, even if the minute-by-minute check that handles expiry has not yet run. The expiry is logged, but in aggregate: one log line records how many requests expired, and the request’s own row stays in the expired state. I do not currently log each expiry as a separate event, and I write this down because my original plan promised that.
What it costs. It is slower, and there are more manual steps. An action waiting for approval stands still until someone looks at it or the expiry decides in their place.
What remains open, and this is the most important part.
- In the code the level is data, and the agent keeps to it according to its own instructions. The system does not physically forbid an action just because the category stands at “notify only”. A gate enforced in code exists for sending email. Anyone who reads that “it does not act without approval” needs to know that this sentence is not true in that form.
- Approval of sending an email can be decided only by the owner logged in to the interface, not with an access key (token). In the code this rule is off by default; on my installation it is on (I confirmed this on 10 November 2026), but whoever installs my system has to switch it on separately.
- I did not find the logging of level changes complete: a change to the expiry and to the owner-decision setting is logged, but changing the level is not logged as a separate log row.
- I have no formal risk classification and no technical documentation.
3. Second decision: fail closed
The problem. A safety check can fail: it can stop, hit a timeout, or not start at all. The system can then do one of two things: let the action through (“fail-open” behaviour) or stop it (“fail-closed” behaviour).
The rule. NIS2 requires essential and important entities to take appropriate and proportionate risk-management measures, among other things in the areas of business continuity and supply chain security. The Hungarian transposition, Section 6 of Act LXIX of 2024 on the cybersecurity of Hungary, places this on the head of the organisation: they must establish and operate a risk management framework (Section 6(2)), they must ensure the traceability of the events of the information system (Section 6(5)(c)), and a periodic assessment of the protective measures is also expected (Section 6(3), point 10). The status of the text in force is valid from 1 October to 31 December 2026.
Why it concerns me, the maker of the software. The rule applies to the organisation concerned, not to me. The Act, however, also states that if the organisation uses a contractor for the creation, operation, maintenance or repair of the information system, or for data processing, it must ensure that the cybersecurity requirements needed for the contractor’s activity are met as contractual obligations (Section 6(5)(d)), and the head of the organisation remains responsible for this (Section 6(6)). The requirement therefore reaches me too, through the supply chain, by way of contract, questionnaire and right of audit. I have not examined whether my own business would fall directly within the scope of the Act.
What I designed: the gates. I first explain what a gate is, because this decision rests on it. An agent does not just chat: it takes steps. It runs a command, fetches a web page, reads or writes a file, sends a letter. A gate is a small programme that runs before such a step, looks at what the agent wants, and either lets it through or stops it. If it stops it, the agent gets an explanation back and the step does not happen. It is like an inspector at the door: it does not do the work for me, it only makes sure the wrong step does not start.
What gates there are. Today I have 11 gate scripts. Their kinds, in everyday language:
- Sending email. Sub-agents cannot send email at all. The main agent’s email goes out only if a person said yes to exactly that email: the approval is tied to the email’s fingerprint (hash), so if the text changes by a single letter, the approval is not valid. The approval request expires in 60 minutes, and the email has to be sent within 30 minutes of the approval being given. Only I can say yes, logged in to the interface; an agent cannot approve its own email with its own access key. A separate gate also checks the text of the email before an approval is spent on it (for example, it rejects Hungarian text written without accents).
- External network. A web page can be fetched only from an allowed address (allowlist), and other external content reaches the agent through an isolated reader, so that it does not arrive as an instruction. Another gate stops network connections started from the command line.
- Dangerous commands. Deletion, moving files, administrator rights, credential folders and touching the
.envfile (where the passwords are): the gate stops these. - Login and permissions. An agent cannot create a login, a session or an access key, and it cannot approve its own approval request.
- Signing the approval. The server signs approvals with a key. Reading this key is forbidden on every tool by a gate, because whoever reads it could forge an approval. This is not the gate for “all secrets”, only for this one key; the protection of passwords goes through the dangerous-commands gate.
- Autonomy and limits. A sub-agent cannot schedule itself and cannot write the gates’ files or the settings files. This is needed so that an agent cannot switch off its own limit.
- Separation and accidental execution. A tenant’s own skill (a trained capability of the agent) can be used only in that tenant’s request, and text pasted into a command must not accidentally run as a command.
An example from practice. If an agent tries to read the .env file, the dangerous-commands gate stops it before the step: it prints that the file contains credentials, and blocks with exit code 2. The agent cannot get around it, it can only report to me or to the main agent. One important limit: the gates catch accidental or lazy mistakes, not a determined workaround, and several gates say this in their own description.
Why the gate blocks when it fails. A gate is only a programme too, so it can break: it can stop, hit a timeout, or not start at all. Here is the trap. Claude Code, which the agents run on, reads only exit code 2 as a block. It treats every other error as if nothing had happened, and lets the action through. So by default a broken gate opens the door. The setting on the gate’s entry (onFailure: block) turns this around: with it, if the gate fails, the step stops. I learned this at my own expense. On 1 November 2026 I tried the timeout live: with the setting the call was stopped, without it the call ran. This is why the setting is mandatory on every gate, a check reports it as an error if it is missing anywhere, and start-up writes in the missing one. In addition, two gates stop themselves after 8 seconds, and if their exit code is neither 0 nor 2, they convert it to 2 themselves, that is, they block. The dangerous-commands gate also answers its own failure with a block.
What it costs. There are more false alarms and more manual approvals. My own experience: the gate sometimes stops read-only commands too, if the text of the command contains the name of a protected file. This is the price of failing closed, and it happened while I was collecting the material for this article as well.
What remains open.
- The gates protect the agents’ tool calls. They do not cover what happens in the host machine’s own shell.
- Availability and continuity: my system runs on one machine, in one database file. The backup is a nightly archive, not a second copy. I make no availability commitment. For the business continuity expectation of NIS2 I have no good answer today, and the next part is about this as well.
- Incident reporting chain: there is none. Gate failures and alerts are internal notifications, not reports to the authorities. Under the Hungarian rules, the organisation concerned must make an initial notification of an incident within 24 hours and an incident report within 72 hours, and must submit a final report within one month of the end of handling (under Section 77(1) of Government Decree 418/2024; Section 66 of the Act says only that it must be done without delay, as set out in the government decree). I have not yet built such a chain in a documented way.
4. Third decision: deletion and data minimisation
The problem. The fate of data is decided where, when I design the system, I decide what to store, for how long, and how it can be deleted. Deletion is not a button: it is also a matter of what I can still find afterwards.
The rule. The GDPR requires data minimisation (data adequate, relevant and limited to what is necessary for the purpose, Article 5(1)(c)), storage limitation (identifiable form only for as long as necessary to achieve the purpose, Article 5(1)(e)), the right to erasure (Article 17), data protection by design and by default (Article 25) and security proportionate to the risk (Article 32). The references are verified on a secondary source, at the level of extracts. The tension lies between deletion and the log: deletion expects no trace to remain, auditability expects that one does. Article 17(3) lists exceptions under which erasure cannot be demanded, among them compliance with a legal obligation and the establishment, exercise or defence of legal claims. In my reading, the log and the audit can have legitimate arguments in such cases; whether keeping a specific trace falls within this in practice is not my decision.
What I designed.
- Tenant deletion. A tenant is a separately managed user organisation, and the tenant identifier marks it. On deletion, all of the tenant’s records are deleted in a single database transaction, in 16 steps: the approvals and their log, the messages, the task board, the memory together with its search index, the schedules, the skills and their files, the documents, the users, the device keys, the channel bindings and the SSH keys. If the deletion fails, the database part rolls back.
- The order of the secrets. The store of secrets is a file, so the deletion of secrets happens after the transaction. If this fails, the tenant’s row is already gone and the secrets remain until I repeat the deletion. The deletion can be repeated, and the error is also passed on to the caller. “The secrets disappear with the deletion” is therefore true only after the secrets have been deleted successfully.
- Measurement and log. Deleting a tenant is a logged operational event, with numbers (how many memories, secrets and schedules went). Telemetry and logs that carry a tenant identifier are also deleted.
- Retention clean-up. A daily maintenance job deletes the expired rows. The defaults: the audit tables 90 days, the approval events 365 days, the trace spans 30 days, the message log 90 days; the live setting may differ. The clean-up logs itself too (with per-table numbers, in one transaction with the deletion): there is no deletion without a log.
- Metadata in the audit trail. The trail of skill changes stores a fingerprint (hash), not text, because a skill can contain anything and the audit log is read by a wider circle. I state this only for the skill trail; I have not examined the other audit tables from this point of view all the way through.
A deliberate decision, not a gap. Three things remain even after a tenant is deleted: the fingerprint rows of the access keys (revoked, fingerprint only), the agent audit and the gate audit. These record who changed what and when, and what each gate said. I decided that deletion takes the tenant’s data, not the trail of accountability. This is a design price: “complete deletion from everywhere” is not true. In the same way, a shared agent or a row that cannot be assigned to a tenant remains.
What it costs. Less trace for troubleshooting, because what I delete I cannot look at later.
What remains open.
- The backups: deletion does not touch them. A deleted tenant’s data (and its secrets, with the backed-up key that belongs to them) stays in the archives already made until the clean-up pushes them out (by default I keep 30 archives). I do not promise immediate deletion that extends to the backups.
- There is no tenant data portability guarantee. There is an export that moves a group of agents to another installation, but it carries the group’s settings (autonomy levels, model setting, schedules, outbound network list, password-protected secrets), not a tenant’s data. The tenant deletion path has no “export first” step.
- Tenant isolation is at application level (the queries filter on the tenant identifier, there is permission management, and a sender-route table), and the database does not enforce it. There is no row-level security; the system today is built on an SQLite file, the preparation for Postgres is in place, but Postgres is not in production use.
5. What code cannot solve
What the three decision cards have in common is that code is only one part of the answer. The contract in the supply chain, the assignment of roles and responsibility, the process for reporting incidents, the periodic independent assessment and certification are not code questions. Of these, my system today has no independent review and no certificate, and my incident process is undocumented.
Suggest a reading of the rule. If you work in data protection or compliance, go through the three decision cards and write to me if you read a rule differently. I need that even more than I need code.
6. What binds when: a timeline
Of the deadlines, I mark as verified only what has been checked against a primary (in-force) text, and I flag separately what comes from a secondary source.
| Event | When | Status |
|---|---|---|
| Hungarian NIS2 transposition: initial notification / incident notification / final report | 24 hours / 72 hours / 1 month after handling | Verified (Government Decree 418/2024 (XII. 23.), Section 77(1), version in force from 11 September 2026 to 31 December 2027) |
| Next version in force of the cybersecurity Act | 1 January 2027 | Verified (as indicated by the legal database), I have not examined its content |
| AI Act, general application | 2 August 2026 | Verified on a secondary source (Article 113) |
| Application to stand-alone high-risk systems (Annex III, Article 6(2)) under the amended text | 2 December 2027 | Verified on a secondary source: the pages for Articles 113, 12, 13, 14 and 19 agree |
| High-risk systems embedded in products (Annex I, Article 6(1)) under the amended text | 2 August 2028 | Verified on a secondary source, the same pages |
The deadlines of the AI Act changed because of a postponing amendment, and the two dates that the table gives from the amended text are reported consistently by two public websites run by third parties that follow the text. I have not read the Official Journal text in this article, so I treat these as dates “verified on a secondary source”, and I do not state the number of the postponing regulation or the day of its publication. I do not mention the 2030 deadline for public authorities, because I could not verify it.
7. In numbers
Here too I measure only what can be verified, and next to each figure I give the method and its limit. The measurements were taken on 10 November 2026.
- Autonomy categories: 15 (5 / 9 / 1). What it measures: the number of categories read on the interface of the running system, by level (notify only, approval-required, autonomous), and how many of these are locked (5). What it does not measure: whether the agent keeps to the level; the level is an instruction to the agent, except for sending email.
- Gate scripts: 11. What it measures: the number of scripts that work as gates, counted in the source code. The figure is the number of scripts, not of entries in the settings.
- Blocking CI steps: 28. What it measures: the named check steps of two CI workflows (CI is the automatic check that runs on changes), without the setup and upload steps: the main workflow has 29 steps, of which 26 are blocking (3 only report), and the secret-scanning workflow has 2 more blocking ones. “Blocking”: a failure of the step fails the workflow. What it does not measure: whether GitHub also forbids merging a change when a step fails; that does not live in the code, and I do not claim it. The measurement is a static count of the definitions, not a runtime statistic.
- The full test suite does not run on a pull request. For a change, the tests that touch the modified files run (along the import graph); the full suite with the coverage thresholds runs only on a push to the main branch. A failing test therefore catches a change only if the change reaches it through the import graph.
- Retention, defaults. Audit tables 90 days, approval events 365, trace spans 30, message log 90; backups: 30 archives. What it does not measure: the live setting.
- Tenant deletion: 16 steps in one transaction. What it measures: the number of deletion steps in the code. What it does not measure: the data left in the backups.
8. What this does not solve
First, an important piece of context. What I write about here is today a product intended for small and medium-sized businesses, and it is still in the development phase. I am not talking about a live, operating enterprise environment. The list is therefore not a fault list of a working service, but a description of where development stands and what I still have to solve before anyone uses it in production.
What this does not solve. I have no formal risk classification and no technical documentation under the AI Act. I have no documented incident reporting chain. I have no availability commitment and no second copy: one machine, one SQLite file, a nightly archive. Tenant isolation is at application level today, not enforced by the database, and row-level security is not switched on. This is the next big step, and it is already under way: the preparation for the move has been done (there is an asynchronous database layer, and the tenant identifiers on the tables are in the code), and the Postgres database and row-level security come next. The level is not a code-level block, except for sending email, and the owner-decision rule for that is off by default in the code (on in my installation). Tenant deletion does not touch the backups, and there is no tenant data portability guarantee. There is no external SIEM integration (the OTLP export is not one). There is no independent review and no certificate. The legal statements are my reading; there has been no formal legal review.
9. What comes next
The question of the series is what this system gives a small business or a larger company compared with the original. On regulation, the answer is three decisions, each with its flaws: autonomy is adjustable and has an expiry, failure blocks, and deletion deliberately chooses what it takes and what it keeps.
Two of the three cards lead back to the same place. One: if I have to delete, and to prove that nothing is left there either, what can I rely on: the discipline of my code, or the database? The other: if a rule expects continuity from me, what can I rely on: a single machine and a single file, or storage that lives in more than one place? Together they mean that, besides the discipline of the code, I will also need the capabilities of the storage underneath it. The next part is about this: what scaling, proving isolation and running in more than one place require.