🤖 AI

ObjectGraph: From Document Injection to Knowledge Traversal -- A Native File Format for the Agentic Era

Dit artikel introduceert OBJECTGRAPH (.og), een native bestandsformaat dat documenten herconceptualiseert als doorloopbare, getypeerde kennisgrafieken in plaats van lineaire tekst, waardoor autonome LLM-agenten tot 95,3% tokenreductie kunnen bereiken zonder nauwkeurigheidsverlies door alleen relevante informatie op te halen via een strikte superset van Markdown.

Oorspronkelijke auteurs: Mohit Dubey, Open Gigantic

Gepubliceerd 2026-05-01

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Mohit Dubey, Open Gigantic

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je probeert een zeer slimme, maar ongelooflijk hongerige robot een specifieke taak aan te leren, zoals "de printer repareren".

Op dit moment is de manier waarop we met deze robots (AI-agenten genoemd) praten, alsof we hen een hele bibliotheek vol boeken geven, alleen omdat ze één pagina in één boek hoeven te lezen.

Het Probleem: De "Hele Bibliotheek"-Aanpak

Op dit moment, als een robot moet weten hoe een printer te repareren, geven we hem de volledige "Printerhandleiding".

De Verspilling: De handleiding is 100 pagina's lang. De robot heeft alleen de 2 pagina's over "papierstoringen" nodig. Maar omdat de robot lineair leest (van boven naar beneden), moet hij alle 100 pagina's doorslikken.
De Kosten: Dit verspilt een enorm aantal "aandachtspunten" (tokens) aan irrelevante informatie zoals "geschiedenis van printers" of "hoe je inkt vervangt".
Het Oplopen: Als de robot vervolgvragen moet stellen, moet hij elke keer opnieuw de hele 100-pagina's handleiding lezen, plus de conversatiegeschiedenis. De kosten exploderen, net als een sneeuwbal die een heuvel afrolt en steeds groter wordt.

De auteurs van dit artikel zeggen: "Stop met het voeden van de robot met de hele bibliotheek. Geef hem in plaats daarvan een kaart."

De Oplossing: ObjectGraph (.og)

Ze hebben een nieuw bestandsformaat bedacht dat ObjectGraph (.og) heet. Denk hierbij niet aan een document, maar aan een slimme, interactieve kaart van de informatie.

Hier is hoe het werkt, met eenvoudige analogieën:

1. Eerst de "Inhoudsopgave" (Het Register)

In een normaal document moet je het hele ding lezen om te vinden wat je nodig hebt. In ObjectGraph begint het bestand met een klein, supersnel Register (ongeveer zo groot als een tweet).

Hoe het werkt: De robot leest eerst dit kleine register. Het zegt: "Oh, ik moet een printer repareren? Het register vertelt me dat de sectie 'Papierstoring' hier is, en de sectie 'Inkt' daar."
Het Voordeel: De robot ziet de rest van het document nooit, tenzij hij er specifiek om vraagt. Het bespaart direct 95% van de leestijd.

2. De "Ui"-lagen (Progressieve Openbaarmaking)

Stel je een ui voor. Je hoeft niet het hele ding in één keer te schillen.

Laag 1 (Dicht): De robot krijgt een korte samenvatting van de sectie (bijv. "Controleer het papierlade").
Laag 2 (Volledig): Als de robot de reparatie daadwerkelijk moet uitvoeren, schilt hij de volgende laag af om de volledige instructies te krijgen.
Het Voordeel: De robot krijgt alleen het "vlees" van de informatie die hij voor de huidige stap nodig heeft, niet de rommel.

3. De "Geheime Agent"-Deuren (Rolafbakening)

Stel je een gebouw voor waar verschillende mensen verschillende sleutels hebben.

De Manager (Orchestrator) heeft een sleutel voor de kamer "Geheime API-sleutels".
De Stagiair (Worker) heeft alleen een sleutel voor de kamer "Algemene Instructies".
Hoe het werkt: In ObjectGraph weet het bestand zelf wie het leest. Als de Stagiair om het bestand vraagt, kan de robot de geheime kamer fysiek niet zien. Het is alsof het document automatisch de gevoelige delen verbergt op basis van wie er vraagt. Er is geen extra beveiligingssoftware nodig; het bestand is de bewaker.

4. De "Zelfcontrolerende" Robot (Uitvoerbare Asserties)

Stel je een recept voor met een ingebouwde kwaliteitscontrole.

Normaal Recept: "Bak de cake." (Je hoopt dat het klaar is).
ObjectGraph Recept: "Bak de cake. ALS de cake niet goudbruin is, DAN bak 5 minuten langer. ALS hij verbrandt, DAN bel de manager."
Het Voordeel: De instructies vertellen de robot precies wat te doen als er iets misgaat, zonder dat een mens een nieuwe prompt hoeft te schrijven.

Waarom Dit Belangrijk Is (De Resultaten)

De auteurs hebben dit getest met echte documenten (zoals technische handleidingen en runbooks) en ontdekte:

Enorme Besparingen: Ze verminderden de hoeveelheid informatie die de robot moest lezen met 60% tot 95%.
Geen Fouten: Hoewel de robot minder las, maakte hij niet meer fouten. Sterker nog, hij was vaak nauwkeuriger omdat hij niet in de war werd door irrelevante informatie.
Mensvriendelijk: Het beste deel? Je kunt deze bestanden nog steeds schrijven in een formaat dat eruitziet als normale tekst (Markdown). Mensen kunnen ze lezen, en robots kunnen ze "bevragen". Het is een strikte upgrade die niets van het oude kapotmaakt.

De Conclusie

Het artikel betoogt dat we proberen een "formaatprobleem" op te lossen met "prompt engineering" (proberen betere instructies te schrijven). In plaats daarvan veranderden ze de container zelf.

ObjectGraph verandert een statisch, zwaar boek in een dynamische, lichtgewicht database die robots direct kunnen navigeren, waardoor geld, tijd en verwarring worden bespaard.

1. Probleemstelling: Het Documentconsumptieprobleem

Het paper identificeert een fundamenteel architecturaal misverstand tussen huidige autonome LLM-agents en bestaande documentformaten (voornamelijk Markdown).

De Kernkwestie: Bestaande formaten zijn ontworpen voor lineair menselijk lezen, waarbij het volledige document in het werkgeheugen wordt gehouden. LLM-agents opereren echter via retrieval. Wanneer een agent informatie nodig heeft, moet het momenteel het hele document injecteren in zijn contextvenster.
Drie Falingsmodi:
1. Tokeninflatie: Agents verspillen ~94% van de tokens aan irrelevante inhoud (bijvoorbeeld het lezen van een runbook van 1.800 tokens om 80 tokens aan relevante stappen te vinden).
2. Contextcompounding: In multi-turn loops wordt de volledige conversatiegeschiedenis (inclusief irrelevante ingevoegde tekst) bij elke API-aanroep opnieuw verzonden, waardoor de tokenkosten superlineair groeien.
3. Rolblindheid: Bestaande formaten kunnen geen verschillende weergaven van hetzelfde document dienen aan verschillende agentrollen (bijvoorbeeld een orchestrator versus een worker) zonder externe middleware.
Beperkingen van eerdere werken: Contextcompressie, RAG en semantische bestandssystemen behandelen symptomen maar falen in het oplossen van de oorzaak: het documentformaat zelf mist een query-adressabele index, getypeerde afhankelijkheden en native toegangscontrole.

2. Methodologie: Het ObjectGraph (.og) Formaat

De auteurs stellen OBJECTGRAPH (.og) voor, een bestandsformaat dat documenten herdenkt als getypeerde, gerichte kennisgrafieken in plaats van lineaire strings.

A. Core Abstraction

Een .og-bestand is een graaf $G = (V, E, \lambda, \rho)$ waarbij:

Nodes ( $V$ ): Atomaire semantische eenheden van kennis (bijvoorbeeld een specifieke stap, waarschuwing of concept).
Edges ( $E$ ): Getypeerde afhankelijkheidsrelaties (bijvoorbeeld :requires, :precedes, :see-also).
Scope ( $\rho$ ): Rolgebaseerde toegangscontrole (bijvoorbeeld orchestrator, worker, all).
Manifest: Een lichtgewicht header (::meta, ::schema, ::index) die $O(1)$ ontdekking van relevante nodes mogelijk maakt zonder inhoud te laden.

B. Key Mechanisms

Progressive Disclosure Model (PDM):
- Pass 1 (Index): Leest alleen het ::index-blok (~30 tokens) om relevantie te bepalen.
- Pass 2 (Dense): Leest ::dense-blokken (~12 tokens/node) met trefwoordsamenvattingen voor routing/planning.
- Pass 3 (Full): Leest ::full, ::code of ::steps-blokken (~180 tokens/node) alleen wanneer uitvoering vereist is.
LLM-Native Query Protocol:
- Gebruikt een interface met twee primitieven: search_index (vindt relevante node-ID's) en resolve_context (haalt inhoud op + traverseert automatisch afhankelijkheden).
- LLM-as-Router: De LLM zelf voert de semantische matching uit op de indexstring, waardoor externe vector-databases of trefwoordmatching-algoritmen overbodig worden.
Executable Assertion Nodes: Validatielogica, retry-paden en escalatieregels worden direct in het document gecodeerd (::assertion), waarbij "wat te doen" wordt gescheiden van "hoe te verifiëren".
Delta Loading: Een ::changelog-node stelt agents in staat om alleen bijgewerkte nodes op te halen sinds de laatste versie, waardoor updatekosten worden gereduceerd van $O(n)$ naar $O(\mu)$ .

C. Compatibility

Strict Superset of Markdown: Elk geldig .md-bestand is een geldig .og-bestand.
Transpiler: Een hybride pipeline converteert Markdown naar .og. Het gebruikt deterministische parsers voor inhoudbehoud en beperkte LLM-aanroepen alleen voor het genereren van navigatiemetagegevens (trefwoorden/dense-blokken), wat hoge fideliteit garandeert.

3. Key Contributions

Formal Model: Gedefinieerd het "Document Consumption Problem" en zes structurele eigenschappen die nodig zijn om het op te lossen (Query-Addressable Index, Layered Compression, Typed Dependency Graph, Role-Scoped Access, Executable Assertions, Human Readability).
Format Specification: Geïntroduceerd het .og-formaat, dat tegelijkertijd aan alle zes eigenschappen voldoet.
Query Protocol: Ontworpen een minimaal protocol met twee primitieven dat agents in staat stelt documenten te traverseren zonder volledige injectie.
Transpiler: Een tool gemaakt om bestaande Markdown naar .og te converteren met bewezen inhoudsfideliteit.
Empirical Validation: Omvangrijke evaluatie over 5 documentklassen en 8 taaktypen.

4. Results

Het paper presenteert empirisch bewijs uit een benchmark van 240 documenten en 8 taaktypen met modellen zoals Claude Sonnet 4.5 en GPT-4o.

Token Reduction:
- Mean Reduction: 92,0% reductie in tokenconsumptie per query (van ~2.340 tokens naar ~187 tokens).
- Multi-Turn Savings: In een 5-turn workflow verlaagde ObjectGraph de cumulatieve tokenkosten met 36,5x ten opzichte van Markdown (1.260 tokens versus 46.000 tokens), wat contextcompounding effectief elimineert.
Task Accuracy:
- ObjectGraph kwam overeen met of overtrof de Markdown-accuraatheid op 7 van de 8 taaktypen.
- Significant Gains:
  - Rol-voorwaardelijke toegang: +18,4%
  - Update-detectie: +30,1%
  - Assertie-verificatie: +43,5%
- Opmerking: De enige lichte daling was in "Cross-node reasoning", wat werd opgevangen door expliciete edge-declaraties.
Transpiler Fidelity: Bereikte 98,7% inhoudbehoud op vastgehouden documenten.
Human Authoring: Gebruikersstudies toonden een lage authoring-belasting (2,8/7 op een Likert-schaal), waarbij gebruikers aangaven dat expliciete tags de documentatiediscipline verbeterden.

5. Significance and Impact

Paradigm Shift: Verplaatst de industrie van "documenten injecteren" naar "kennisgrafieken traverseren", waarbij het documentformaat wordt behandeld als de primaire infrastructuur voor agent-intelligentie.
Infrastructure Reduction: Door toegangscontrole, validatielogica en changetracking in het bestandsformaat te coderen, elimineert ObjectGraph de behoefte aan externe middleware (vector DB's, toegangscontrolelagen, validatiescripts), wat de agent-architectuur vereenvoudigt.
Scalability: Het "Less-Is-More"-effect toont aan dat het verminderen van irrelevante context niet alleen geld bespaart, maar ook de modelprestaties verbetert door vermindering van aandachtverdunning.
Future Outlook: Het paper identificeert "federation" (cross-file edge resolution) als de volgende kritieke stap om een gedistribueerde, querybare kennisgraaf te creëren voor het "Agentic Web".

Kortom, ObjectGraph lost de tokeninefficiëntie en structurele beperkingen van huidige agent-documentinteracties op door het document zelf te herdefiniëren als een gestructureerde, traverseerbare en rolbewuste kennisgraaf, waarmee enorme efficiencywinst wordt behaald zonder in te leveren op nauwkeurigheid.