Az enterprise-érettség három pillére: üzemeltethetőség, auditálhatóság, compliance és integráció / The three pillars of enterprise maturity: operability, auditability, compliance and integration

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

Egy AI-asszisztens-rendszert nem a képességei tesznek vállalati környezetben használhatóvá. A képesség a belépő. A döntést az dönti el, hogy a rendszer beilleszthető-e egy meglévő üzemeltetési, biztonsági és megfelelési keretbe. Az elmúlt napban pontosan ezen a rétegen dolgoztam a saját flottámon: a hobbi-eszközből egy olyan platform felé mozdítottam el, amely előre szól, ha valami baj van, dokumentálja, mi változott, és nem okoz meglepetést annak, aki integrálja. Kevés látványos új funkció, annál több üzemeltethetőség, auditálhatóság és compliance-készség. Erről a fejlesztésről írok, és arról, hogy ez a réteg miért az, amelyen egy komoly B2B-beszélgetés elindul vagy elakad.

1. A képesség a belépő, a beilleszthetőség a döntés

Amikor egy szervezet AI-asszisztenst vezetne be, a demó ritkán az akadály. A demó szinte mindig működik. A döntés ott dől el, hogy a rendszer beilleszthető-e a meglévő folyamatokba: futtatható-e a saját infrastruktúrán, kiszámítható-e a viselkedése frissítéskor, dokumentálható-e a változása, és átmegy-e a belső biztonsági átvilágításon. Az én olvasatomban ez a valódi választóvonal a hobbi-projekt és a vállalati eszköz között, és az elmúlt napban ezt a réteget építettem be a flottámba.

Három tulajdonságcsoportra bontottam a munkát: az üzemeltethetőségre, az auditálhatóságra, és a megfelelésre, illetve a beilleszthetőségre. Ezek nem különálló funkciók, hanem egy irányba mutató döntések, és együtt adják ki azt, amit szokás enterprise-érettségnek nevezni. Fontos, hogy ez nem marketingcímke: a lentiek egy konkrét, mérhető állapotot írnak le, nem egy ígéretet.

2. Üzemeltethetőség: a rendszer, ami deploy-időben szól

2.1 Konfiguráció-validáció mint belépési kapu

A tizenkét faktoros alkalmazás elvének egyik sarokpontja, hogy a rendszer ne indulhasson el érvénytelen konfigurációval. Bevezettem egy induláskori, sémára épülő konfiguráció-validációt: ha egy kötelező beállítás hiányzik, rossz a típusa, vagy egy érték kiesik a megengedett tartományból, a szerver el sem indul. Ez vállalati környezetben nem kényelmi funkció, hanem üzemeltetési alap. A hiba ott jelenik meg, ahol elkapható, tehát telepítéskor, nem éles terhelés alatt. A séma ráadásul önálló dokumentáció is: egyetlen helyen leírja az összes konfigurálható paramétert, azok típusát és alapértékét.

2.2 Titok-kezelés kiszervezve, környezetenként

A titkos adatok (hitelesítő kulcsok, tokenek) kezelését elválasztottam a kódbázistól. A megoldás egy egyértelmű elsőbbségi sorrendet követ: a kifejezett felülírás, majd a futásidőben becsatolt titok (például a konténer /run/secrets/ könyvtárából), majd a helyi .env, végül az alapérték. Ez pontosan az a rétegelt kezelés, amit a Kubernetes- és Docker-alapú telepítéseknél elvárnak: a titok soha nem kerül a kódba, a konténer-lenyomatba vagy a telepítési leírásba, hanem futásidőben, jogosultsággal vezérelt csatornán jut a folyamathoz. Az eredmény egyetlen mondatban: a lokális fejlesztés .env fájllal megy, a köztes környezet Docker-titokkal, az éles Kubernetes titok-becsatolással, és a kód egyetlen sort sem változik a három között.

Egy kódbázis, három környezet: a titok-kezelés kiszervezése dev, staging és prod között, boot-időben validált konfigurációval / One codebase, three environments: externalised secret handling across dev, staging and prod, with configuration validated at boot time
Ugyanaz a kód fut mindhárom környezetben; a különbséget a becsatolt titok és a konfiguráció adja, nem a build.

3. A stabil szerződés: verziózott API és kontraktus

3.1 Verziózás és kivezetési ablak

A legdrágább, mégis megelőzhető integrációs hiba az, amikor egy interfész inkompatibilis változása visszamenőlegesen leveri a rá épülő klienseket, és az incidens forrása napokig rejtve marad. Bevezettem az URL-alapú API-verziózást: a kanonikus útvonal mostantól a /api/v1/*, a régi /api/* pedig megszűnt helyett elavuló aliasként él tovább, a szabványos Sunset (RFC 8594) és Deprecation (RFC 9745) fejlécekkel. Ehhez tartozik egy írott kivezetési házirend is, benne egy legalább hathónapos ablakkal: ennyi ideig mindkét változat elérhető, a régi pedig gépileg olvasható dátummal jelzi, mikor vonom ki. Ez akkor számít igazán, ha az integrátor kiadási ciklusa eltér a platformétól: a vállalati kliens nem kénytelen azonnal követni minden változást, de a határidő egyértelmű.

Stabil integrátor-szerződés: kanonikus verziózott útvonal, elavuló alias Sunset fejléccel, hathónapos kivezetési ablak és a változást blokkoló CI-kapu / A stable integrator contract: a canonical versioned path, a deprecated alias with a Sunset header, a six-month retirement window and a CI gate that blocks a breaking change
A rendszer változhat, a szerződés stabil: a régi és az új verzió egy ideig együtt él, a törő változást pedig a CI blokkolja.

3.2 OpenAPI, generált SDK, CI-védelem

A teljes API-felületet gépileg olvasható OpenAPI 3.1 leírásba foglaltam, hetven végpontra. Ez önmagában is érték, de a valódi különbséget két dolog adja. Az egyik egy generátor, amely a leírásból állítja elő a kliens-oldali kódkészletet, így a spec a forrás, nem a kézzel írt kód, és a kettő nem csúszhat szét. A másik egy folyamatos integrációs kapu, amely minden módosításnál összeveti az aktuális leírást az előzővel, és megbukik, ha törő változást talál: végpont törlése, kötelező mező hozzáadása, típusváltás mind detektált. Így a törő változás nem éles incidensként derül ki, hanem a beolvasztás előtt, a fejlesztő asztalán.

4. Auditálhatóság: ami nincs leírva, nem történt meg

A kiadásokhoz emberi olvashatóságú, verzióhoz kötött változásnaplót vezettem be, és egy folyamatos integrációs szabályt, amely kikényszeríti a naprakészségét: ha egy API-felületet érintő módosításhoz nem tartozik naplóbejegyzés, a folyamat elbukik. Ez megfelelési szempontból az "ami nincs leírva, nem is történt" elvét valósítja meg. Az auditáló nem a nyers verziótörténetet böngészi, hanem egy emberi szerkesztésű, verziószámhoz rendelt leírást olvas.

Ez a réteg illeszkedik a korábban beépített eszközökhöz. A rendszer futásidőben is vezet audit naplót, és elosztott nyomkövetéssel követi az ágensek közötti üzenetváltást: ki, mikor, milyen művelettel, milyen eredménnyel. Ez az elszámoltathatósági réteg az, amire egy NIS2-vizsgálat, egy ISO 27001 belső audit vagy egy nagyvállalati üzemeltetési felülvizsgálat épít. Az ellenőrzött mentés és a tesztelt visszaállítás pedig azt biztosítja, hogy az elszámoltathatóság mellett az adatok helyreállíthatósága is bizonyítható legyen.

5. A compliance-nézőpont: NIS2, önhosztolás, adatkontroll

Az önhosztolt, auditálható és verziókövetett rendszer közvetlen összhangban van a NIS2 és a hasonló szabályozói keretek elvárásaival. Az incidens-követhetőség, a konfiguráció reprodukálhatósága és a belső adatkontroll olyan tényezők, amelyekre a megfelelési dokumentáció tételesen hivatkozhat. Ez különösen azoknak a szervezeteknek fontos, amelyek szeretnének AI-asszisztenst, de adatot nem adhatnak ki külső felhőbe: itt az önhosztolás nem kompromisszum, hanem a megfelelés egyik feltétele, mert az infrastruktúra, a memória és az adatok a saját környezetben maradnak, és az adatkezelési lánc átlátható. A modellhívás viszont külső szolgáltatóhoz megy: ezt külön, megnevezhető harmadik félként kell kezelni.

Két korábbi kontroll is ebbe az irányba mutat. Az ágensenkénti eszköz-hatáskör a legkisebb jogosultság elvét alkalmazza: minden ágens csak azokat az eszközöket és adatokat éri el, amelyek a feladatához kellenek, így egy félrekonfigurált vagy kompromittált ágens kártétele korlátozott marad. A visszafordíthatatlan műveletekhez pedig kötelező emberi jóváhagyás tartozik, ami a magasabb kockázatú folyamatoknál elvárt kontroll-pontot építi be. Együtt ez a kettő érezhetően csökkenti a rendszer üzemeltetési kockázati profilját.

6. Miért számít ez egy döntéshozónak

Ha egy sorba kellene sűrítenem, mit ad ez a réteg egy technológiai vezetőnek, az így hangzana: a rendszer változhat, a szerződés stabil. Egy verziózott, kontraktussal rögzített és folyamatos integrációval védett interfész azt jelenti, hogy a beépítő fél, akár belső csapat, akár külső szállító, kiszámítható alapot kap. Ez csökkenti az incidens-reaktív munkát és a tervezési bizonytalanságot, ami az üzemeltetési teher nagy részét adja.

A biztonsági vezető szemszögéből az auditálhatóság nem a jó tervezés mellékterméke, hanem a szállítói átvilágítás egyik szűrőpontja. Ahol a konfiguráció és a titkok kezelése nem ellenőrizhető, ott a kockázati profil eleve magasabb, és ez közvetlenül befolyásolja, hogy egy rendszer átmegy-e a belső biztonsági vizsgálaton. Szerintem éppen ezért éri meg ezt a réteget a képességek elé sorolni: a képességet könnyű bemutatni, a beilleszthetőséget viszont fel kell építeni, és a beszerzési döntés utóbbin múlik.

Fontos hangsúlyoznom, hogy ez egy saját, önállóan továbbfejlesztett rendszeren végzett munka, nem termékbejelentés. A célom nem egy kész vállalati platform hirdetése, hanem annak bemutatása, milyen konkrét mérnöki döntések visznek egy AI-asszisztenst a beilleszthetőség felé, és miért ezek döntik el a valódi adoptációt.

7. Összefoglalás

Egy nap alatt nem lesz enterprise-termék egy AI-flotta, és nem is ez volt a cél. Az viszont látszik, hogy mely rétegek különböztetik meg a bemutatható eszközt a beilleszthető rendszertől: az üzemeltethetőség, amely deploy-időben szól, ha valami rossz; az auditálhatóság, amely dokumentálja a változást; és a megfelelési készség, amely az önhosztolásra és az adatkontrollra épül. Az én olvasatomban ezek nem külön funkciók, hanem egy irány, és aki AI-t vinne komoly szervezeti környezetbe, annak ezen a rétegen érdemes kezdenie a mérlegelést, nem a képességlistán.

A cikk a cett/marveen fork deploy- és integrációs-érettségi rétegének 2026-08-24-i állapotát tükrözi.

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: 24 August 2026 | Source: Own development

It is not its capabilities that make an AI assistant system usable in an enterprise environment. Capability is the entry ticket. What decides is whether the system can be fitted into an existing operational, security and compliance framework. Over the past day I worked on exactly this layer on my own fleet: I moved it from a hobby tool towards a platform that warns in advance when something is wrong, documents what has changed, and holds no surprises for whoever integrates it. Few spectacular new features, all the more operability, auditability and compliance readiness. I write about this development, and about why this is the layer on which a serious B2B conversation starts or stalls.

1. Capability is the entry ticket, enterprise fit is the decision

When an organisation is about to introduce an AI assistant, the demo is rarely the obstacle. The demo almost always works. The decision is made on whether the system can be fitted into existing processes: can it run on its own infrastructure, is its behaviour predictable at update time, can its changes be documented, and does it pass the internal security review. In my reading this is the real dividing line between a hobby project and an enterprise tool, and over the past day I built this layer into my fleet.

I split the work into three groups of properties: operability, auditability, and compliance together with integrability. These are not separate features but decisions pointing in one direction, and together they make up what is usually called enterprise maturity. It matters that this is not a marketing label: what follows describes a concrete, measurable state, not a promise.

2. Operability: the system that speaks up at deploy time

2.1 Configuration validation as an entry gate

One of the cornerstones of the twelve-factor app methodology is that the system must not be able to start with an invalid configuration. I introduced a schema-based configuration validation at start-up: if a mandatory setting is missing, has the wrong type, or a value falls outside the permitted range, the server does not even start. In an enterprise environment this is not a convenience feature but an operational baseline. The error appears where it can be caught, that is, at installation, not under live load. The schema is also documentation in itself: in a single place it describes all configurable parameters, their types and default values.

2.2 Secret handling moved out of the code, per environment

I separated the handling of secret data (credentials, tokens) from the codebase. The solution follows a clear order of precedence: the explicit override, then the secret mounted at runtime (for example from the container's /run/secrets/ directory), then the local .env, finally the default. This is exactly the layered handling that is expected in Kubernetes and Docker-based deployments: the secret never gets into the code, the container image or the deployment description, but reaches the process at runtime, through a channel controlled by permissions. The result in one sentence: local development runs with an .env file, the staging environment with a Docker secret, the live one with a Kubernetes secret mount, and the code does not change by a single line between the three.

One codebase, three environments: externalised secret handling across dev, staging and prod, with configuration validated at boot time
The same code runs in all three environments; the difference comes from the mounted secret and the configuration, not from the build.

3. The stable contract: a versioned API with a fixed contract

3.1 Versioning and the retirement window

The most expensive yet preventable integration fault is when an incompatible change of an interface retroactively breaks the clients built on it, and the source of the incident stays hidden for days. I introduced URL-based API versioning: the canonical path is now /api/v1/*, and the old /api/* lives on as a deprecated alias instead of being switched off, with the standardised Sunset (RFC 8594) and Deprecation (RFC 9745) headers. With this goes a written retirement policy as well, with a window of at least six months: both versions are available for that long, and the old one signals with a machine-readable date when I will withdraw it. This matters most when the integrator's release cycle differs from the platform's: the enterprise client is not forced to follow every change at once, but the deadline is clear.

A stable integrator contract: a canonical versioned path, a deprecated alias with a Sunset header, a six-month retirement window and a CI gate that blocks a breaking change
The system may change, the contract is stable: the old and the new version live together for a while, and a breaking change is blocked by continuous integration (CI).

3.2 OpenAPI, a generated SDK, CI protection

I put the whole API surface into a machine-readable OpenAPI 3.1 description, covering seventy endpoints. This is valuable in itself, but two things make the real difference. One is a generator that produces the client-side code set from the description, so the spec is the source, not hand-written code, and the two cannot drift apart. The other is a continuous-integration gate that compares the current description with the previous one at every change, and fails if it finds a breaking change: a deleted endpoint, a newly mandatory field or a changed type are all detected. This way a breaking change does not come to light as a live incident but before the merge, on the developer's desk.

4. Auditability: what is not written down did not happen

For releases I introduced a human-readable, version-bound changelog, and a continuous-integration rule that enforces that it is kept up to date: if a change touching the API surface has no changelog entry, the pipeline fails. From a compliance point of view this implements the principle that "what is not written down did not happen". The auditor does not browse the raw version history but reads a human-edited description tied to a version number.

This layer fits in with the tools built earlier. At runtime the system also keeps an audit log, and follows the message exchange between agents with distributed tracing: who, when, with what operation, with what result. This accountability layer is what a NIS2 review, an ISO 27001 internal audit or a large-enterprise operations review builds on. And the verified backup and the tested restore ensure that besides accountability, the recoverability of the data can also be demonstrated.

5. The compliance view: NIS2, self-hosting, data control

A self-hosted, auditable and version-tracked system is in direct line with the expectations of NIS2 and similar regulatory frameworks. Incident traceability, the reproducibility of the configuration and internal data control are factors that compliance documentation can cite item by item. This is especially important for organisations that would like an AI assistant but cannot hand data out to an external cloud: here self-hosting is not a compromise but one of the conditions of compliance, because the infrastructure, the memory and the data stay in the organisation's own environment, and the data-handling chain is transparent. The model call, however, goes to an external provider: that has to be treated as a separate, named third party.

Two earlier controls point in the same direction. Per-agent tool scope applies the principle of least privilege: every agent reaches only the tools and data that its task needs, so the damage a misconfigured or compromised agent can do stays limited. And irreversible operations come with mandatory human approval, which builds in the control point expected for higher-risk processes. Together these two noticeably reduce the operational risk profile of the system.

6. Why this matters to a decision-maker

If I had to condense into one line what this layer gives a technology leader, it would be: the system may change, the contract is stable. An interface that is versioned, fixed by a contract and protected by continuous integration means that the party building on it, whether an internal team or an external supplier, gets a predictable base. This reduces incident-reactive work and planning uncertainty, which make up the greater part of the operational burden.

From the security lead's point of view, auditability is not a by-product of good design but one of the filter points of supplier due diligence. Where the handling of configuration and secrets cannot be verified, the risk profile is higher from the start, and this directly affects whether a system passes the internal security review. In my view that is exactly why it is worth putting this layer ahead of capabilities: a capability is easy to demonstrate, whereas fit has to be built, and the procurement decision depends on the latter.

I must stress that this is work 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 engineering decisions move an AI assistant towards fitting in, and why these decide real adoption.

7. Summary

An AI fleet does not become an enterprise product in a day, and that was not the aim. What is visible, though, is which layers distinguish a demonstrable tool from a system that can be fitted in: operability, which speaks up at deploy time when something is wrong; auditability, which documents the change; and compliance readiness, which rests on self-hosting and data control. In my reading these are not separate features but a direction, and whoever would take AI into a serious organisational environment should start their evaluation at this layer, not at the capability list.

This article reflects the state of the deployment and integration-maturity layer of the cett/marveen fork on 24 August 2026.

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.