🤖 AI

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

This paper introduces OBJECTGRAPH (.og), a native file format that reconceives documents as traversable, typed knowledge graphs rather than linear text, enabling autonomous LLM agents to achieve up to 95.3% token reduction without accuracy loss by retrieving only relevant information through a strict superset of Markdown.

Original authors: Mohit Dubey, Open Gigantic

Published 2026-05-01

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mohit Dubey, Open Gigantic

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a very smart, but incredibly hungry, robot how to do a specific job, like "fix the printer."

Currently, the way we talk to these robots (called AI agents) is like handing them a whole library of books just because they need to read one page in one book.

The Problem: The "Whole Library" Approach

Right now, if a robot needs to know how to fix a printer, we give it the entire "Printer Manual."

The Waste: The manual is 100 pages long. The robot only needs the 2 pages about "paper jams." But because the robot reads linearly (top to bottom), it has to swallow all 100 pages.
The Cost: This wastes a huge amount of "attention" (tokens) on irrelevant info like "history of printers" or "how to change ink."
The Compounding: If the robot has to ask follow-up questions, it has to re-read the entire 100-page manual every single time, plus the conversation history. The cost explodes, like a snowball rolling down a hill getting bigger and bigger.

The authors of this paper say: "Stop feeding the robot the whole library. Give it a map instead."

The Solution: ObjectGraph (.og)

They created a new file format called ObjectGraph (.og). Think of it not as a document, but as a smart, interactive map of the information.

Here is how it works, using simple analogies:

1. The "Table of Contents" First (The Index)

In a normal document, you have to read the whole thing to find what you need. In ObjectGraph, the file starts with a tiny, super-fast Index (about the size of a tweet).

How it works: The robot reads this tiny index first. It says, "Oh, I need to fix a printer? The index tells me the 'Paper Jam' section is right here, and the 'Ink' section is over there."
The Benefit: The robot never even sees the rest of the document unless it specifically asks for it. It saves 95% of the reading time immediately.

2. The "Onion" Layers (Progressive Disclosure)

Imagine an onion. You don't need to peel the whole thing at once.

Layer 1 (Dense): The robot gets a tiny summary of the section (e.g., "Check paper tray").
Layer 2 (Full): If the robot needs to actually do the fix, it peels back the next layer to get the full instructions.
The Benefit: The robot only gets the "meat" of the information it needs for the current step, not the fluff.

3. The "Secret Agent" Doors (Role Scoping)

Imagine a building where different people have different keys.

The Manager (Orchestrator) has a key to the "Secret API Keys" room.
The Intern (Worker) has a key only to the "General Instructions" room.
How it works: In ObjectGraph, the file itself knows who is reading it. If the Intern asks for the file, the robot physically cannot see the secret room. It's like the document automatically hides the sensitive parts based on who is asking. No extra security software is needed; the file is the security guard.

4. The "Self-Checking" Robot (Executable Assertions)

Imagine a recipe that has a built-in quality check.

Normal Recipe: "Bake the cake." (You hope it's done).
ObjectGraph Recipe: "Bake the cake. IF the cake is not golden brown, THEN bake for 5 more minutes. IF it burns, THEN call the manager."
The Benefit: The instructions tell the robot exactly what to do if something goes wrong, without needing a human to write a new prompt.

Why This Matters (The Results)

The authors tested this with real documents (like technical manuals and runbooks) and found:

Massive Savings: They reduced the amount of information the robot had to read by 60% to 95%.
No Mistakes: Even though the robot read less, it didn't make more mistakes. In fact, it was often more accurate because it wasn't confused by irrelevant information.
Human Friendly: The best part? You can still write these files in a format that looks like normal text (Markdown). Humans can read them, and robots can "query" them. It's a strict upgrade that doesn't break anything old.

The Bottom Line

The paper argues that we are trying to solve a "format problem" with "prompt engineering" (trying to write better instructions). Instead, they changed the container itself.

ObjectGraph turns a static, heavy book into a dynamic, lightweight database that robots can navigate instantly, saving money, time, and confusion.

1. Problem Statement: The Document Consumption Problem

The paper identifies a fundamental architectural mismatch between current autonomous LLM agents and existing document formats (primarily Markdown).

The Core Issue: Existing formats are designed for linear human reading, where the entire document is held in working memory. LLM agents, however, operate via retrieval. When an agent needs information, it currently must inject the entire document into its context window.
Three Failure Modes:
1. Token Inflation: Agents waste ~94% of tokens on irrelevant content (e.g., reading a 1,800-token runbook to find 80 tokens of relevant steps).
2. Context Compounding: In multi-turn loops, the full conversation history (including irrelevant injected text) is re-transmitted on every API call, causing token costs to grow super-linearly.
3. Role Blindness: Existing formats cannot serve different views of the same document to different agent roles (e.g., an orchestrator vs. a worker) without external middleware.
Limitations of Prior Work: Context compression, RAG, and semantic file systems address symptoms but fail to solve the root cause: the document format itself lacks a query-addressable index, typed dependencies, and native access control.

2. Methodology: The ObjectGraph (.og) Format

The authors propose OBJECTGRAPH (.og), a file format that reconceives documents as typed, directed knowledge graphs rather than linear strings.

A. Core Abstraction

An .og file is a graph $G = (V, E, \lambda, \rho)$ where:

Nodes ( $V$ ): Atomic semantic units of knowledge (e.g., a specific step, warning, or concept).
Edges ( $E$ ): Typed dependency relationships (e.g., :requires, :precedes, :see-also).
Scope ( $\rho$ ): Role-based access control (e.g., orchestrator, worker, all).
Manifest: A lightweight header (::meta, ::schema, ::index) that allows $O(1)$ discovery of relevant nodes without loading content.

B. Key Mechanisms

Progressive Disclosure Model (PDM):
- Pass 1 (Index): Reads only the ::index block (~30 tokens) to determine relevance.
- Pass 2 (Dense): Reads ::dense blocks (~12 tokens/node) containing keyword summaries for routing/planning.
- Pass 3 (Full): Reads ::full, ::code, or ::steps blocks (~180 tokens/node) only when execution is required.
LLM-Native Query Protocol:
- Uses a two-primitive interface: search_index (finds relevant node IDs) and resolve_context (fetches content + auto-traverses dependencies).
- LLM-as-Router: The LLM itself performs the semantic matching on the index string, eliminating the need for external vector databases or keyword matching algorithms.
Executable Assertion Nodes: Validation logic, retry paths, and escalation rules are encoded directly in the document (::assertion), separating "what to do" from "how to verify."
Delta Loading: A ::changelog node allows agents to fetch only updated nodes since the last version, reducing update costs from $O(n)$ to $O(\mu)$ .

C. Compatibility

Strict Superset of Markdown: Every valid .md file is a valid .og file.
Transpiler: A hybrid pipeline converts Markdown to .og. It uses deterministic parsers for content preservation and bounded LLM calls only for generating navigational metadata (keywords/dense blocks), ensuring high fidelity.

3. Key Contributions

Formal Model: Defined the "Document Consumption Problem" and six structural properties required to solve it (Query-Addressable Index, Layered Compression, Typed Dependency Graph, Role-Scoped Access, Executable Assertions, Human Readability).
Format Specification: Introduced the .og format, satisfying all six properties simultaneously.
Query Protocol: Designed a minimal, two-primitive protocol enabling agents to traverse documents without full injection.
Transpiler: Created a tool to convert existing Markdown to .og with provable content fidelity.
Empirical Validation: Comprehensive evaluation across 5 document classes and 8 task types.

4. Results

The paper presents empirical evidence from a benchmark of 240 documents and 8 task types using models like Claude Sonnet 4.5 and GPT-4o.

Token Reduction:
- Mean Reduction: 92.0% reduction in token consumption per query (from ~2,340 tokens to ~187 tokens).
- Multi-Turn Savings: In a 5-turn workflow, ObjectGraph reduced cumulative token costs by 36.5x compared to Markdown (1,260 tokens vs. 46,000 tokens), effectively eliminating context compounding.
Task Accuracy:
- ObjectGraph matched or exceeded Markdown accuracy on 7 out of 8 task types.
- Significant Gains:
  - Role-conditional access: +18.4%
  - Update detection: +30.1%
  - Assertion verification: +43.5%
- Note: The only slight dip was in "Cross-node reasoning," which was mitigated by explicit edge declarations.
Transpiler Fidelity: Achieved 98.7% content preservation on held-out documents.
Human Authoring: User studies showed a low authoring burden (2.8/7 on a Likert scale), with users noting that explicit tags improved documentation discipline.

5. Significance and Impact

Paradigm Shift: Moves the industry from "injecting documents" to "traversing knowledge graphs," treating the document format as the primary infrastructure for agent intelligence.
Infrastructure Reduction: By encoding access control, validation logic, and change tracking inside the file format, ObjectGraph eliminates the need for external middleware (vector DBs, access control layers, validation scripts), simplifying agent architecture.
Scalability: The "Less-Is-More" effect demonstrates that reducing irrelevant context not only saves money but improves model performance by reducing attention dilution.
Future Outlook: The paper identifies "federation" (cross-file edge resolution) as the next critical step to create a distributed, queryable knowledge graph for the "Agentic Web."

In summary, ObjectGraph solves the token inefficiency and structural limitations of current agent-document interactions by redefining the document itself as a structured, traversable, and role-aware knowledge graph, achieving massive efficiency gains without sacrificing accuracy.