ObjectGraph: From Document Injection to Knowledge Traversal A Native File Format for the Agentic Era Mohit Dubey
·
Open Gigantic
arXiv:2604.27820v1 [cs.AI] 30 Apr 2026
Abstract Every document format in existence was designed for a human reader moving linearly through text. Autonomous LLM agents do not read—they retrieve. This fundamental mismatch forces agents to inject entire documents into their context window, wasting tokens on irrelevant content, compounding state across multi-turn loops, and broadcasting information indiscriminately across agent roles. We argue this is not a prompt engineering problem, not a retrieval problem, and not a compression problem: it is a format problem. We introduce O BJECT G RAPH (.og), a file format that reconceives the document as a typed, directed knowledge graph to be traversed rather than a string to be injected. O BJECT G RAPH is a strict superset of Markdown—every .md file is a valid .og file—requires no infrastructure beyond a two-primitive query protocol, and is readable by both humans and agents without tooling. We formalize the Document Consumption Problem, characterise six structural properties no existing format satisfies simultaneously, and prove O BJECT G RAPH satisfies all six. We further introduce the Progressive Disclosure Model, the Role-Scoped Access Protocol, and Executable Assertion Nodes as native format primitives. Empirical evaluation across five document classes and eight agent task types demonstrates up to 95.3% token reduction with no statistically significant degradation in task accuracy (p > 0.05). Transpiler fidelity reaches 98.7% content preservation on a held-out document benchmark.
1 Introduction
of magnitude. We formalise this as the Context Compounding Problem in Section 2.
The past three years have witnessed the rapid deployment of autonomous LLM agents across domains ranging from software engineering to scientific discovery. These agents—whether orchestrating multi-step workflows, maintaining persistent knowledge bases, or coordinating with specialised sub-agents—share a common dependency: they consume documents. Skill files describe capabilities. Runbooks encode operational procedures. Execution plans coordinate multi-agent pipelines. Configuration files constrain behaviour. In nearly every case, these documents are written in Markdown. Markdown was designed in 2004 by Gruber [Gruber, 2004] for human authors producing web content. Its design assumptions are deeply human-centric: content is read linearly, from top to bottom; the reader holds the full document in working memory; relevance is determined by eye rather than by query. None of these assumptions hold for LLM agents.
Prior Approaches and Their Limits. Existing work addresses adjacent aspects of this problem but not the format itself. Context compression systems [Xiao et al., 2026, Gao et al., 2026] reduce token counts by removing content, but preserve the injection model and do not eliminate multi-turn compounding. Retrieval-Augmented Generation (RAG) [Lewis et al., 2020] retrieves passages from external corpora but requires vector database infrastructure and cannot encode typed relationships, executable logic, or access control. Semantic file systems [Mei et al., 2024] provide LLM-aware file management but require persistent services. Token-efficient serialisation formats such as TOON [Schopplich, 2025] reduce structured data payloads but are not document formats—they encode records, not knowledge. This Paper. We identify that the problem is not in how agents process documents but in how documents are structured. We propose O BJECT G RAPH (.og), a format that treats the document as a typed knowledge graph whose nodes are semantic units of information and whose edges are typed dependency relationships. Agents interact with .og files through a two-primitive query protocol—search_index and resolve_context—that retrieves only the nodes relevant to the current task, automatically traversing declared dependencies, and filtering content by agent role.
The Core Mismatch. When an agent is invoked with a task— “deploy the application to staging”—its runtime reads the relevant skill file in its entirety and injects the full content into the context window. For a typical 600-line deployment runbook, this costs approximately 1,800 tokens. The content relevant to the specific task—perhaps 80 tokens—represents a 4.4% utilisation rate. The remaining 1,720 tokens (95.6%) are wasted on irrelevant sections, background explanations, and content scoped to other roles or scenarios. This waste is not merely expensive; it is structurally harmful. Contributions. This paper makes the following contributions: As agents operate in multi-turn loops—searching, reading, ex- • A formal model of the Document Consumption Problem and ecuting, verifying, and searching again—each document read the six structural properties a format must satisfy to solve it is appended to the conversation history. Because LLM APIs (Section 2). are stateless, this history is re-transmitted in full on every subsequent call. A five-turn loop involving three document reads • The O BJECT G RAPH format specification: a complete, can compound the original 1,800 tokens into 15,000+, making human-readable, infrastructure-free document format satisfythe multi-turn overhead exceed the document cost by an order ing all six properties (Section 4). 1
• The LLM-Native Query Protocol: a two-primitive interface This grows super-linearly in both T and n. A five-turn loop enabling agents to traverse .og files without loading them reading a 1,800-token document once can cost ≈9,000 tokens into context (Section 5). in transmission overhead alone. • A hybrid transpiler converting arbitrary Markdown to .og F3: Role Blindness. In multi-agent systems, orchestrator agents, worker agents, and read-only monitoring agents require with provable content fidelity (Section 6). different views of the same document. No existing format • An empirical evaluation across 5 document classes and 8 supports role-conditional content serving at the format level; task types demonstrating 60–95% token reduction without all consumers receive identical content. accuracy loss (Section 8). 2.3 Six Required Properties
2 The Document Consumption Problem
We derive six necessary properties from the three failure modes:
2.1 Formal Model Definition 2: Required Properties for Agent-Native Docs
Let D be a document of n tokens, partitioned into k semantic sections D = {s1 , s2 , . . . , sk } where |si | denotes the token Pk count of section i and i=1 |si | = n. An agent task τ is associated with a relevance set R(τ ) ⊆ {1, . . . , k} such that |R(τ )| ≪ k in general.
P1 Query-Addressable Index: O(1) mapping from semantic query to relevant section identifiers. P2 Layered Compression: Multiple fidelity levels (summary, full, code) natively encoded per section. P3 Typed Dependency Graph: Explicit, machine-traversable relationships between sections.
Definition 1 (Full-Read Assumption). A document format F satisfies the Full-Read Assumption if the minimum cost of retrieving any content from a document formatted as F is Ω(n), i.e. proportional to the total document size regardless of |R(τ )|.
P4 Role-Scoped Access Control: Content filtered by consumer role at format level, without external middleware. P5 Executable Assertions: Validation conditions, retry logic, and escalation paths encoded in the document.
Proposition 1. Markdown, plain text, JSON, YAML, and HTML all satisfy the Full-Read Assumption.
P6 Human Readability: Directly authored and read by humans without compilation or tooling.
This follows from the absence of a query-addressable index in these formats. Without an index, an agent cannot determine Table 1 positions O BJECT G RAPH against prior formats which sections are relevant without reading all of them. across these six properties. 2.2 Three Failure Modes
Table 1: Property satisfaction matrix across formats. ✓ = full, F1: Token Inflation. The per-query token cost under the Full- ◦ = partial, × = absent. Read Assumption is Cread (τ ) = n regardless of |R(τ )|. Define the Utilisation Rate as: Format P1 P2 P3 P4 P5 P6 P Markdown × × × × × ✓ i∈R(τ ) |si | U(τ ) = (1) JSON / YAML × × ◦ × × ◦ n TOON llms.txt GraphRAG LSFS SkillReducer
Our empirical analysis of 1,247 real-world agent task executions across five document classes finds Ū = 0.063, meaning agents use on average only 6.3% of injected content. The remaining 93.7% constitutes pure waste.
× ◦ ✓ ✓ ◦
× × × × ◦
× × ✓ ◦ ×
× × × × ×
× × × × ×
◦ ✓ × × ✓
F2: Context Compounding. In multi-turn agentic loops, LLM O BJECT G RAPH ✓ ✓ ✓ ✓ ✓ ✓ APIs are stateless: the full conversation history must be retransmitted on every call. Let ht denote the history token count at turn t. If an agent executes m document reads across a workflow, the total token cost is: 3 Related Work Context Compression. A substantial body of work addresses T T X X X h0 + Ctotal = ht = cj (2) token reduction through content removal. Xiao et al. [2026] remove useless, redundant, and expired information from agent t=1 t=1 j≤t trajectories, achieving 39.9–59.7% input token reduction on where cj is the cost of operation j and h0 is the initial context. coding agents. Gao et al. [2026] report 48% description comFor m document reads, each costing n tokens, in a T -turn pression and 39% body compression through progressive disclosure in skill bodies. Huang et al. [2025] achieve 22.7% workflow: reduction through autonomous compression during execution. Ccompound = T · h0 + m · n · (T − tread + 1) (3) Critically, these approaches compress content within the injec2
tion model; they do not eliminate full-reads or context com- 4.2 File-Level Structure pounding, because the document format remains unchanged. Every .og file begins with three mandatory blocks read during Structured Knowledge for Agents. Shi et al. [2025] evalu- the index pass. ate schema representation formats (YAML, Markdown, JSON, TOON) for file-native agentic systems. Their evaluation covers Listing 1: File-level manifest of an .og document. SQL generation accuracy, finding that no single format dominates across model tiers. TOON [Schopplich, 2025] achieves 1 ::meta 25–46% token reduction over JSON for structured data pay- 2 title: Python Deployment Runbook 3 version: 2.3.0 loads, but explicitly targets record serialisation rather than 4 updated: 2025-04 document representation and provides no graph traversal, de- 5 domain: deployment|python|devops 6 scope: all pendency resolution, or human authoring model. 7 checksum: sha256:a3f9c2... 8
Graph-Based Knowledge. Edge et al. [2024] construct entity graphs from document corpora for global search; their approach requires vector databases and offline indexing pipelines, making it unsuitable as a general-purpose document format. Shi et al. [2026] build knowledge graphs from code repositories using tree-sitter, achieving structural retrieval advantages but restricted to code corpora. FatCat [2025] propose a documentdriven multi-agent system using Markdown as a “high-SNR semantic file system”, noting that Markdown’s alignment with LLM pretraining priors reduces attention dilution—a key motivation for our Markdown superset design.
::end
9 10 11 12 13 14 15 16
::schema node-types: [concept,step,warning, example,assertion,meta] edge-types: [requires,precedes, see-also,supersedes] scope-levels:[all,orchestrator,worker] ::end
17 18 19 20 21 22
File-Native Agent Context. The industry has converged on file-based context patterns: CLAUDE.md, AGENTS.md, CURSOR.rules, and llms.txt [llms.txt, 2024]. These are statically read, entirely injected, and provide no query interface. They represent the state of practice that O BJECT G RAPH directly supersedes.
23 24 25 26 27
Skill Representation. Jiang et al. [2026] introduce the Scheduling-Structural-Logical (SSL) representation for agent skills, drawing on classical knowledge representation theory. Their work addresses the internal structure of skills but does not address the file format through which skills are stored, retrieved, or consumed at runtime. O BJECT G RAPH is complementary: SSL-structured skills can be stored as .og nodes.
::index # id |type |scope |conf|keywords install |step |all |0.99|install,pip,venv, setup configure |step |all |0.97|config,env, variables deploy-prod |step |all |0.95|deploy,prod, release api-keys |step |orchestrator|0.99|vault,secret,api, key troubleshoot |step |all |0.90|error,debug,fail post-install |assert|all |1.00|verify,check, assert __changelog |meta |all |1.00|changes,diff, updates ::end
The ::index block is the critical innovation. At approximately 30 tokens for a typical skill file, it provides a complete routing table that an agent can read to determine task relevance without loading any content nodes. 4.3 The Node: Atomic Knowledge Unit Every semantic unit in an .og file is a node—a typed container with a stable identifier, scope annotation, confidence score, and versioning metadata:
4 The ObjectGraph Format 4.1 Core Abstraction O BJECT G RAPH models a document as a directed, typed graph G = (V, E, λ, ρ) where:
n = ⟨id, type, conf, scope, updated, content_blocks, edges⟩ (4) The node identifier is immutable across versions, enabling cross-document edge references and diff-based delta loading (Section 4.9).
• V is a set of nodes, each representing a self-contained semantic unit of knowledge. • E ⊆ V × V is the edge set of typed dependencies. • λ : E → L is an edge labelling function over a typed label set L (e.g., :requires, :precedes).
4.4 Content-Type Tags: Richer than Markdown
• ρ : V → S is a scope function mapping nodes to access roles A fundamental limitation of Markdown is that content type is S (e.g., all, orchestrator, worker). encoded only visually—a code fence, a blockquote, and a bullet The file-level structure serves as the graph’s manifest: a list look different to a human but are semantically indistinguishlightweight, always-read header that enables O(1) node discov- able to an agent. O BJECT G RAPH introduces explicit semantic type annotations for every content block. ery before any content is loaded. Table 2 provides the complete taxonomy. 3
Table 2: ObjectGraph content-type tags and their semantic contracts.
Listing 2: A complete node demonstrating all content layers. 1 2 3
::node[id=install type=step confidence=0.99 scope=all updated=2025-04 entry=true]
Tag
Semantic Meaning
Behaviour
::dense ::full ::code[lang] ::steps ::list ::table ::warning ::note ::example ::reference ::assertion ::summary
Compressed keyword summary Complete prose explanation Executable/technical content Ordered sequential actions Unordered enumeration Structured relational data Critical safety information Informational aside Concrete illustration External citation or URL Executable validation logic Human-authored précis
Always; Pass 2 Pass 3 Verbatim Order kept Any order Verbatim Never skip Optional Skippable On demand Post-exec Alt. dense
4 5 6 7 8
::dense python3.11+|pip|venv|requirements.txt| activate|--break-system-packages ::end
9 10 11 12 13 14
::full Ensure Python 3.11+ is installed. Create and activate a virtual environment before installing project dependencies. ::end
15 16 17 18 19 20 21
::steps 1. python -m venv .venv 2. source .venv/bin/activate # Linux/Mac 3. .venv\Scripts\activate # Windows 4. pip install -r requirements.txt ::end
22 23 24 25 26 27
::code[lang=bash] python -m venv .venv source .venv/bin/activate pip install -r requirements.txt ::end
For typical values (n = 1,800, |M (τ )| = 2, |F (τ )| = 1): Cog = 30 + 2·12 + 1·180 = 234, yielding Savings = 87.0%.
28 29 30 31 32 33
::warning Never install packages globally. Virtual environment isolation prevents dependency conflicts across projects. ::end
4.6 Typed Edge Declarations Edges are declared within each node’s ::edges block using a concise directed-graph syntax:
34 35 36 37 38 39
::edges ->[:precedes] ->[:precedes] ->[:requires] ::end
configure post-install concept-virtualenv
Listing 3: Edge syntax with conditional edges. 1 2
40 41
3
::end # install
4 5 6 7 8
4.5 The Progressive Disclosure Model
::edges ->[:precedes] configure ->[:requires] concept-virtualenv <-[:used-in] deploy-prod <>[:related] troubleshoot ->[:see-also condition=’query contains k8s’] kubernetes-deploy ::end
The label set L includes: :requires, :precedes, The Progressive Disclosure Model (PDM) is the central mech:contradicts, :elaborates, anism by which O BJECT G RAPH eliminates token inflation. :contains, :see-also, :supersedes, :used-in. Every node exposes three reading depths: Automatic Dependency Traversal. When the query protoPass 1 — Index Pass (∼30 tokens, fixed) col resolves a node, it automatically follows all :requires Read ::meta + ::index. Determine which nodes are relevant. edges and fetches prerequisite nodes. This means an agent Pass 2 — Dense Pass (∼10–15 tokens/node) querying “deploy to production” receives not only the deploy Read ::dense blocks of matched nodes. Sufficient for routing node but also its declared dependencies (e.g., configure, apiand planning decisions. keys), without issuing additional queries. Pass 3 — Full Pass (∼100–300 tokens/node) Read ::full, ::code, ::steps, etc. Required only for task execution.
4.7 Role-Based Access Control The scope attribute on both index entries and nodes implements a first-class role-based access control layer at the format level. The ::index exposes scope information in Pass 1, so an agent with role r never even learns of the existence of nodes with ρ(n) ∈ / {r, all}. This eliminates the need for external access control middleware in document-serving pipelines—a significant reduction in system complexity for multi-agent deployments.
The cost model for a single query τ is: Cog (τ ) = Cindex + |M (τ )| · c̄d + |F (τ )| · c̄f
(5)
where M (τ ) is the set of matched nodes read at dense level, F (τ ) ⊆ M (τ ) is the subset requiring full-pass reading, c̄d ≈ 12 tokens, and c̄f ≈ 180 tokens. Comparing to the baseline Cmd (τ ) = n: 4.8 Executable Assertion Nodes Savings(τ ) = 1 −
Cog (τ ) n
Assertion nodes encode validation logic, retry routing, and (6) escalation paths directly in the document. They are triggered 4
Theorem 1 (Backward Compatibility). Every valid Markdown Listing 4: Role-scoped nodes serving different consumers from document is a valid .og document. Specifically, a Markdown the same file. document D parsed as .og is equivalent to a single-node 1 # Orchestrator agent sees real credentials .og document with D’s content in a ::full block, with no 2 ::node[id=api-keys scope=orchestrator ::index, ::dense, or ::edges blocks. Agents fall back 3 type=step confidence=1.0] 4 ::full to full-read behaviour with zero errors. 5 Retrieve production API key from Vault: 6 7 8
vault kv get secret/prod/api-key ::end ::end
This means adoption requires no migration of existing documents—they gain .og capabilities incrementally as authors add structured blocks.
9 10 11 12 13 14 15 16
# Worker agent receives a safe abstraction ::node[id=api-keys scope=worker type=step confidence=1.0] ::full API keys are managed by the orchestrator. Request credentials via: get_secret(’prod/api-key’) ::end ::end
5 The LLM-Native Query Protocol 5.1 Design Rationale
The query protocol is deliberately minimal: two primitives, 17 18 exposed as MCP tools [Anthropic, 2024] or function-calling schemas. More primitives would reintroduce the complexity they are meant to eliminate; fewer would sacrifice either the by the query protocol after the designated predecessor node index-first routing or automatic dependency resolution. completes: Definition 3: The Two-Primitive Query Protocol Primitive 1: search_index(f , q, r) Given file path f , natural language query q, and agent role r, returns a formatted index string listing all node IDs whose keywords overlap with q and whose scope includes r. Token cost: O(Cindex ).
Listing 5: An assertion node encoding post-installation verification. 1 2 3 4 5 6 7 8 9 10 11 12 13
::node[id=post-install type=assertion] ::assertion trigger: after[install] check: command(’python --version’) matches ’Python 3\.1[0-9]’ check: file_exists(’.venv/bin/activate’) on-pass: ->[:proceed] configure on-fail: ->[:retry limit=2] install on-fail-after-retries: ->[:escalate] troubleshoot timeout: 30s ::end ::end
Primitive 2: resolve_context(f , N ) Given file path f and a set of node IDs N , returns the full content of all nodes in N plus all nodes reachable via :requires edges within a declared depth limit. Token cost: O(|N | · c̄f + |Er | · c̄f ) where Er is the set of required dependency nodes.
5.2 LLM as Router A critical insight is that the index search is performed by the LLM, not by a keyword-matching algorithm. The agent reads the index string and uses its full semantic understanding to decide which nodes are relevant—far superior to BM25 or embedding similarity for the structured, domain-specific content of agent files. This pattern, which we term LLM-as-Router, requires no fine-tuning: any instruction-following model can perform it from a one-paragraph system prompt addition. Algorithm 1 provides the full query workflow.
Assertion nodes eliminate the need to encode validation logic in agent prompts, reducing prompt length and separating what to do (in nodes) from whether it succeeded (in assertions). 4.9 Delta Loading via Changelog The ::changelog meta-node enables incremental document consumption. An agent that has previously read a document at version v can determine all changes since v by reading only the changelog node (∼30 tokens), then fetching only the delta nodes:
5.3 Architectural Instantiations O BJECT G RAPH supports two architectures depending on document scale:
Listing 6: Changelog node enabling delta-based document updates. 1 2 3 4 5 6 7
::node[id=__changelog type=meta] ::changelog 2025-04-15|added |node[kubernetes-deploy] 2025-04-10|updated|node[install] 2025-03-01|deprecated|node[heroku-deploy] ::end ::end
Architecture A: One-Shot Injection (small files, n < 10k tokens). The ::index block (∼150 tokens) is injected into the system prompt at session start. The agent calls resolve_context exactly once per task. No search tool call, no multi-turn compounding. Total protocol overhead: zero.
Proposition 2. For a document updated at rate µ (nodes/month) and consumed q times between updates, delta loading Architecture B: Router/Executor Delegation (large files, n ≥ 10k tokens). A lightweight Router agent (e.g., Claude reduces update-check cost from O(n) to O(µ · c̄f ). Haiku) receives search_index and outputs a JSON array of 4.10 Backward Compatibility node IDs. The orchestration layer calls resolve_context O BJECT G RAPH is a strict superset of Markdown: locally. An Executor agent (e.g., Claude Sonnet) receives only 5
Architecture A (small files)
Algorithm 1: ObjectGraph Query Protocol Input: File f , task description τ , agent role r, session S Output: Context payload P
1 call
index ← parse_index(f , role=r); 2 candidates ← filter_by_confidence(index, θ = 0.80); 3 N ← LLMROUTER (candidates, τ ); /* LLM selects node IDs */ 4 N ← N \ S.visited; /* skip-if-known filter */ 5 deps ← resolve_edges(f , N , :requires); 6 Nfull ← N ∪ deps; 7 for ni ∈ Nfull do 8 if has_warning(ni ) then 9 P ← P ∪ fetch_full(f , ni ); 10 end 11 else if τ requires execution then 12 P ← P ∪ fetch_full(f , ni ); 13 end 14 else 15 P ← P ∪ fetch_dense(f , ni ); 16 end 17 S.visited ← S.visited ∪ {ni }; 18 end 19 return P ; 1
Agent
Index (system prompt)
reads once
resolve_ context
Architecture B (large files)
Router Agent
query
search_ index
node IDs
resolve_ context payload only
no share
d history
Executor Agent
Figure 1: Two architectural instantiations of the ObjectGraph query protocol. Architecture B eliminates context compounding by design: the Executor agent receives zero tool-call history.
6.2 Stage 1: Deterministic Structural Extraction Algorithm 2 describes the rule-based parser. It operates as a single-pass state machine with O(n) complexity. Table 3 summarises the Markdown-to-O BJECT G RAPH mapping rules.
the resolved context payload—zero tool-call history, zero com- 6.3 Stage 2: Bounded LLM Metadata Synthesis pounding. Figure 1 illustrates both architectures. For each node ni , a single LLM call generates the ::dense 5.4 Session Memory and Skip-If-Known block (8–12 pipe-separated keywords) and ::index query The session object S maintains a visited-node set across turns. terms. The prompt is deliberately constrained: the LLM reNodes annotated with skip-if-known=true (typically ceives only the ::full prose blocks (never code or table concept nodes explaining foundational background) are content) and is instructed to produce keywords rather than parafetched at most once per session, regardless of how many times phrase. This bounds hallucination exposure to navigational metadata. they appear in subsequent dependency traversals. Proposition 3 (Session Savings). In a workflow visiting k distinct nodes across T turns, with a fraction α of nodes marked skip-if-known, the session savings relative to turn-independent reading is: ∆session = α · k · (T − 1) · c̄f
Stage 2 LLM Prompt Template You are generating search index keywords. Node: {node_id} | Type: {node_type} Prose content: {full_content[:500]} DENSE (max 15 tokens, pipe-separated technical keywords, no verbs, no articles): INDEX (5-8 comma-separated query terms, include synonyms):
(7)
For α = 0.3, k = 10, T = 5, c̄f = 180: ∆session = 2,160 tokens saved in addition to per-query savings.
6 The Transpiler: Markdown to ObjectGraph
Respond with exactly two lines. No explanation. No markdown formatting.
6.1 Design Principles The transpiler converts arbitrary Markdown documents to .og through a three-stage hybrid pipeline grounded in one invariant: LLMs never touch actual content. LLMs generate only navigational metadata (::dense blocks and ::index keywords). All content is copied verbatim by deterministic parsers, bounding hallucination risk to routing pointers rather than information.
6.4 Stage 3: Fidelity Verification The verification pass is deterministic and non-negotiable. It produces a fidelity score ϕ ∈ [0, 1] and blocks deployment if ϕ < 0.95. ϕ=
6
cp − α · |A| ct
(8)
Table 3: Markdown to ObjectGraph structural mapping rules.
Algorithm 2: Stage 1: Rule-Based Structural Extraction Input: Markdown document D Output: Node list N N ← []; ncur ← ∅; 2 foreach line ℓ in D do 3 if ℓ matches /## .+/ then 4 close(ncur ); append to N ; 5 ncur ← N EW N ODE(slugify(ℓ)); 6 else if ℓ matches /“‘[\w]*/ then 7 b ← R EADV ERBATIM B LOCK(); 8 ncur .A DD B LOCK(code, b); 9 else if ℓ matches /\|.+\|/ then 10 b ← R EAD TABLE B LOCK(); 11 ncur .A DD B LOCK(table, b); 12 else if ℓ matches /^\d+\./ then 13 b ← R EAD S TEP B LOCK(); 14 ncur .A DD B LOCK(steps, b); 15 else if ℓ starts with > [!WARNING] then 16 b ← R EADWARNING B LOCK(); 17 ncur .A DD B LOCK(warning, b); 18 else 19 ncur .A PPEND F ULL(ℓ); 20 end 21 end 22 return N ; 1
Markdown Element
O BJECT G RAPH Tag
Treatment
## heading “‘lang...“‘ | table | 1. 2. 3. ordered - bullet > [!WARNING] > [!NOTE] [text](url) Paragraph prose **bold**
::node[id=slug] ::code[lang=X] ::table ::steps ::list ::warning ::note ::reference ::full In ::full
Node boundary Verbatim Verbatim Order kept Verbatim Verbatim Verbatim If standalone Verbatim No extraction
pressed in .og encode not just steps (::steps) but dependencies (::edges), success criteria (::assertion), and role assignments (scope). Plans become self-verifying: each step asserts its own completion before the next is resolved. UC4: Technical Documentation. API documentation, architecture guides, and onboarding manuals stored as .og allow both human authors (who see normal Markdown rendering) and agent consumers (who use the query protocol) to interact with the same source file. No dual-maintenance of human and machine versions.
UC5: Multi-Agent Communication Substrates. In multiagent pipelines, .og files serve as the shared knowledge medium. Role-scoped nodes ensure that orchestrator agents, where cp is the number of checks passed, ct is the total worker agents, and monitoring agents each receive precisely number of checks, A is the set of content elements found in the information relevant to their function, from a single source .og but not in the source Markdown (hallucinated additions), of truth. and α = 0.02 is the per-addition penalty. UC6: Knowledge Base Maintenance. The ::changelog Checks include: (i) every code block present verbatim, (ii) evand confidence attributes enable knowledge bases to sigery table row preserved, (iii) every heading mapped to a node nal their own freshness. Automated staleness detection ID, (iv) no content in ::full blocks absent from the source. (updated > k months ago) triggers human review workflows without requiring external metadata tracking.
7 Use Cases
O BJECT G RAPH is a general-purpose document format appli- 8 Evaluation cable wherever Markdown is used today. We describe six primary use cases, each unlocking capabilities impossible with 8.1 Experimental Setup Document Corpus. We constructed a benchmark of 240 docflat Markdown. UC1: Agent Skill Files. The motivating use case. Skills uments across five classes: Skill Files (48), Operational Runwritten as .og nodes allow multi-agent frameworks to route books (52), Execution Plans (44), Technical Documentation tasks to the relevant procedure without injecting the entire skill (56), and Knowledge Bases (40). Documents ranged from 200 library. A skill library of 50 files (∼90,000 tokens total) is to 15,000 tokens (mean 2,340; median 1,680). Task Suite. We defined 8 task types: information lookup, pronavigable via a combined index of ∼1,500 tokens. cedure execution, multi-step planning, role-conditional access, UC2: Operational Runbooks. Enterprise runbooks frequently cross-node reasoning, update detection, assertion verification, exceed 100,000 tokens. Under the full-read model, reading and multi-agent handoff. Each document-task pair was exea runbook to answer “how do I roll back a failed Kubernetes cuted 5 times; we report means and 95% CI. deployment?” costs 100k tokens. Under O BJECT G RAPH, the Models. We evaluate with Claude Sonnet 4.5 (primary), Claude index pass costs ∼200 tokens; context resolution costs ∼600 Haiku 4.5 (Router in Architecture B), and GPT-4o (cross-model tokens. Reduction: 99.2%. validation). UC3: Agent Execution Plans. Multi-step agent plans ex- Baselines. (B1) Full Markdown injection; (B2) RAG with text7
embedding-3-large; (B3) SkillReducer-optimised Markdown.
mitigated by the automatic dependency traversal mechanism (reducing the gap from 4.2% to 1.8% with edge declarations).
8.2 RQ1: Token Consumption
Figure 2 reports token consumption across document classes Table 4: Task accuracy (%) across methods. O BJECT G RAPH(E) and task types. O BJECT G RAPH reduces mean token consump- denotes O BJECT G RAPH with explicit edge declarations. † p < tion from 2,340 to 187 tokens (92.0% reduction; p < 0.001). 0.05 vs. Markdown baseline. 6,000
Task Type
Avg. tokens per query
Markdown (B1) 5,000
RAG (B2)
Information O BJECT G RAPH Arch.A lookup 4,000 O BJECT G RAPH Arch.B Procedure 3,000 execution Multi-step 2,000 planning 1,000 Roleconditional 0 Cross-node s ls ks ans KB Doc Skil boo c Pl Run Tech Exe reasoning Update deFigure 2: Mean token consumption per query across docu- tection ment classes and approaches. O BJECT G RAPH Architecture B Assertion achieves the greatest reduction on large runbooks. verify Multi-agent handoff
MD RAG O BJECT G RAPH O BJECT G RAPH(E) 91.2
87.4
92.1†
92.3†
88.6
83.1
89.4†
90.1†
84.3
79.8
85.7†
86.2†
76.4
71.2
94.8†
95.1†
82.1
74.6
77.9
80.3
61.3
54.7
91.4†
91.6†
52.8
48.1
96.3†
96.5†
71.4
69.3
93.2†
94.1†
76.0
71.0
90.1
90.8
8.3 RQ2: Context Compounding Reduction
Mean
Cumulative tokens (×103 )
We measured total tokens transmitted across a 5-turn agentic workflow, each turn involving one document interaction. Figure 3 shows cumulative token cost as a function of turn number. 50
The dramatic improvement on Role-conditional access (+18.4%), Update detection (+30.1%), and Assertion verification (+43.5%) reflects capabilities absent in Markdown that O BJECT G RAPH encodes natively.
Markdown (B1) RAG (B2) O BJECT G RAPH Arch.A O BJECT G RAPH Arch.B
40 30
8.5 RQ4: Transpiler Fidelity The transpiler was evaluated on 180 held-out documents not in the task benchmark. Mean fidelity ϕ̄ = 0.987 (SD = 0.018). Failures concentrated in two cases: deeply nested blockquotes (which Stage 1 flattens) and multi-paragraph code comments (misclassified as prose). Both are addressed in post-processing. No document fell below the ϕ = 0.95 deployment threshold after human review.
20 10 0
1
2
3
4
5
Turn number
Figure 3: Cumulative token cost in a 5-turn agentic workflow. Markdown exhibits super-linear compounding. O BJECT- 8.6 RQ5: Human Authoring Burden G RAPH Architecture B maintains near-linear growth through We conducted a user study with 18 participants (12 software context isolation. engineers, 6 technical writers) who authored .og files from scratch using only the specification and a one-page cheat sheet. At turn 5, Markdown has accumulated 46,000 tokens verParticipants rated authoring burden on a 7-point Likert scale. sus O BJECT G RAPH Architecture B’s 1,260 tokens—a 36.5× Mean burden: 2.8/7 (SD=1.1). Qualitatively, participants noted reduction. The super-linear growth of Markdown is clearly that the explicit content-type tags (::warning, ::steps, visible; O BJECT G RAPH Arch. B is near-linear due to context ::code) felt “more descriptive than Markdown” and that the isolation. ::dense constraint “forced better documentation discipline.” 8.4 RQ3: Task Accuracy 8.7 Ablation Study Table 4 reports task accuracy across methods and task types. O BJECT G RAPH matches or exceeds Markdown accuracy on 7 Figure 4 shows the contribution of individual O BJECT G RAPH of 8 task types. The single exception—Cross-node reasoning, features to token reduction, isolating the effect of each compowhere Markdown’s full injection provides implicit context—is nent. 8
Adversarial Inputs. We have not evaluated O BJECT G RAPH against adversarial document authors who might craft misleading ::dense blocks or ::index entries to manipulate agent routing.
92
Full O BJECT G RAPH Index routing
28
Delta loading
14
Role scoping
10 Conclusion
8
Skip-if-known
12
Dense layer
We introduced O BJECT G RAPH, a document format that reconceives the Markdown document as a typed knowledge graph traversable by LLM agents. By formalising the Document Consumption Problem and deriving six structural properties necessary for its solution, we demonstrated that no existing format satisfies all six simultaneously, and that O BJECT G RAPH does. Through the Progressive Disclosure Model, the twoprimitive LLM-Native Query Protocol, role-scoped access control, and executable assertion nodes, O BJECT G RAPH reduces agent token consumption by 60–95% with no accuracy penalty, while remaining directly authored and read by humans without tooling. The open problem is federation: a standardised protocol for cross-file edge resolution that would enable .og documents to form a distributed knowledge graph spanning repositories, organisations, and agent ecosystems. This, we believe, is the natural next step toward a structured, queryable substrate for the agentic web.
18 0
20
40
60
80
100
Token reduction (%)
Figure 4: Ablation: token reduction contribution of individual O BJECT G RAPH features. Index routing and the dense layer account for 82% of total savings.
9 Discussion 9.1 The Less-Is-More Effect
A counterintuitive finding is that O BJECT G RAPH not only reduces token cost but improves accuracy on most task types. We attribute this to two mechanisms. First, the elimination of irrelevant content reduces attention dilution—a phenomenon documented by Gao et al. [2026], who found that removing non-essential content improves task performance by 2.8% even References at equivalent token budgets. Second, the semantic content-type tags (::warning, ::steps) provide structural signals that Anthropic. Model Context Protocol (MCP): An open standard for connecting AI assistants to tools and data sources, 2024. https: improve the model’s parsing accuracy, an effect consistent with //modelcontextprotocol.io. Shi et al. [2025]’s finding that structured formats improve agent task performance on file-native systems. D. Edge, H. Trinh, N. Cheng, J. Bradley, A. Chao, A. Mody, S. Truitt, and J. Larson. From local to global: A graph RAG approach to query-focused summarization. arXiv preprint arXiv:2404.16130, 2024.
9.2 ObjectGraph as Infrastructure
We note that O BJECT G RAPH’s adoption implications extend beyond token savings. Role-scoped nodes eliminate the need for document access control middleware in multi-agent pipelines. Anonymous. Fat-Cat: Document-driven metacognitive multi-agent system for complex reasoning. arXiv preprint arXiv:2602.02206, Executable assertions eliminate the need for separate valida2025. tion prompt templates. Delta loading eliminates the need for document change tracking systems. In each case, functionality Y. Gao, Z. Li, Y. Yuan, Z. Ji, P. Ma, and S. Wang. SkillReducer: previously requiring external infrastructure is encoded in the Optimizing LLM agent skills for token efficiency. arXiv preprint document format itself, reducing system complexity and the arXiv:2603.29919, 2026. surface area for failure. J. Gruber. Markdown, 2004. https://daringfireball.net/ projects/markdown/.
9.3 Limitations
Evaluation Scale. Our benchmark of 240 documents, while Anonymous. Active context compression: Autonomous memory carefully curated, does not cover the full diversity of real-world management in LLM agents. arXiv preprint arXiv:2601.07190, document types. Evaluation on enterprise-scale corpora re2025. mains future work. Multi-file Federation. The current specification does not sup- Anonymous. From skill text to skill structure: The SchedulingStructural-Logical representation for agent skills. arXiv preprint port cross-file edge resolution—edges referencing nodes in arXiv:2604.24026, 2026. other .og files. This limits O BJECT G RAPH’s applicability to mono-repo or single-domain knowledge bases. P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, Standardisation. Without a standards body or broad commuH. Küttler, M. Lewis, W.-T. Yih, T. Rocktäschel, S. Riedel, and nity adoption, the format risks fragmentation into incompatible D. Kiela. Retrieval-augmented generation for knowledge-intensive dialects. We recommend an RFC-style governance process as a NLP tasks. In Advances in Neural Information Processing Systems near-term priority. (NeurIPS), 2020. 9
J. Howard. A proposed standard for using Markdown in LLM context, 2024. https://llmstxt.org. W. Mei, Y. Guo, Y. Wang, Z. Li, and H. Zhao. From commands to prompts: LLM-based semantic file system for AIOS. arXiv preprint arXiv:2410.11843, 2024. J. Schopplich. TOON: Token-Oriented Object Notation, 2025. https://toonformat.dev. Anonymous. Structured context engineering for file-native agentic systems. arXiv preprint arXiv:2602.05447, 2025. Anonymous. Codebase-Memory: Tree-Sitter-based knowledge graphs for LLM code exploration via MCP. arXiv preprint arXiv:2603.27277, 2026. Y.-A. Xiao, P. Gao, C. Peng, and Y. Xiong. Reducing cost of LLM agents with trajectory reduction. Proc. ACM Softw. Eng., 3(FSE):FSE056, 2026.
10
A Complete ObjectGraph Format Specification Normative Tag Reference
Tag
Level
Pass
Required
Semantic Contract
::meta ::index ::schema ::node[...] ::dense ::full ::code[lang] ::steps ::list ::table ::warning ::note ::example ::reference ::assertion ::edges ::traverse ::changelog ::end
File File File Container Content Content Content Content Content Content Content Content Content Content Behaviour Navigation Navigation Meta Structural
1 1 1 Any 2 3 3 3 3 3 2+ 3 3 3 Runtime 2 1 1 Any
Yes Yes No Yes Yes Yes No No No No No No No No No No No No Yes
Machine-readable file metadata Complete node routing table Type and edge-type declarations Typed node with attributes ≤15-token keyword compression Complete verbatim prose Executable content; never summarised Ordered sequential actions Unordered enumeration Relational data; never paraphrased Always read; never skipped Optional informational aside Skippable concrete illustration External citation with URL Post-execution validation logic Typed outbound/inbound edges Traversal hint metadata Structured delta-loading log Block terminator (universal)
B Token Cost Model Derivation Let D be an .og document with k nodes indexed in ::index. Define: Cindex = cmeta + k · centry ≈ 30 + 6k tokens Cdense (ni ) ≈ 15 tokens (worst case) code Cfull (ni ) = |nfull | + |nsteps | i | + |ni i
(9) (10) (11)
For a query matching m nodes at dense level and p ≤ m at full level: Cog = Cindex + m · Cdense + p · E[Cfull ]
(12)
The savings ratio over full Markdown injection: Σ=1−
Cog 30 + 6k + 15m + 180p =1− n n
Assuming k = 10, m = 2, p = 1, n = 1800: Σ = 1 − (30 + 60 + 30 + 180)/1800 = 1 − 300/1800 = 83.3%.
C Complete Deployment Runbook Example Listing 7: Production-ready .og deployment runbook demonstrating all format features. 1 2 3 4 5 6
::meta title: Python Application Deployment Runbook version: 2.3.0 author: devops-team updated: 2025-04 domain: deployment|python|devops scope: all checksum: sha256:a3f9c2b1d8... ::end
7 8 9 10 11 12
::schema node-types: [concept,step,warning,example,assertion,meta] edge-types: [precedes,requires,see-also,supersedes] scope-levels:[all,orchestrator,worker,readonly] ::end
13 14
::index
11
(13)
15 16 17 18 19 20 21 22 23 24 25 26
# id |type |scope |conf|keywords install |step |all |0.99|install,pip,venv,setup,python configure |step |all |0.97|config,env,variables,settings deploy-prod |step |all |0.95|deploy,production,release,ship deploy-staging |step |all |0.95|staging,test,preview,sandbox rollback |step |all |0.93|rollback,revert,undo,restore api-keys |step |orchestrator |0.99|vault,secret,api,key,credentials api-keys-worker |step |worker |0.99|api,key,credentials,access troubleshoot |step |all |0.90|error,debug,fail,broken,crash post-install-check|assert|all |1.00|verify,check,assert,validate __changelog |meta |all |1.00|changes,diff,updates,version ::end
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
::node[id=install type=step confidence=0.99 scope=all updated=2025-04 entry=true] ::dense python3.11+|pip|venv|requirements.txt|activate|--break-system-packages ::end ::full Ensure Python 3.11 or higher is installed on the target system. Create and activate a virtual environment before installing dependencies. ::end ::steps 1. Create environment: python -m venv .venv 2. Activate (Linux/Mac): source .venv/bin/activate 3. Activate (Windows): .venv\Scripts\activate 4. Install dependencies: pip install -r requirements.txt 5. System Python only: add --break-system-packages flag ::end ::warning Never install packages globally into the system Python. Virtual environment isolation is mandatory for reproducible deployments and prevents dependency conflicts. ::end ::code[lang=bash] python -m venv .venv && source .venv/bin/activate pip install -r requirements.txt python --version && pip list | grep -E "requests|fastapi" ::end ::edges ->[:precedes] configure ->[:precedes] post-install-check ->[:requires] concept-virtualenv ::end ::end # install
58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
::node[id=post-install-check type=assertion] ::dense verify|python3.11|pip|venv|assert|check ::end ::assertion trigger: after[install] check: command(’python --version’) matches ’Python 3\.1[0-9]’ check: command(’pip list’) contains ’requests’ check: file_exists(’.venv/bin/activate’) on-pass: ->[:proceed] configure on-fail: ->[:retry limit=2] install on-fail-after-retries: ->[:escalate] troubleshoot max-retries: 2 timeout: 30s ::end ::end # post-install-check
75 76 77 78 79 80 81 82 83 84 85 86 87
::node[id=api-keys type=step confidence=1.0 scope=orchestrator updated=2025-04] ::dense vault|prod-api-key|kv-secret|orchestrator-only ::end ::full Retrieve the production API key from the internal Vault instance. ::end ::code[lang=bash] vault kv get secret/prod/api-key export API_KEY=$(vault kv get -field=value secret/prod/api-key) ::end ::end # api-keys
88 89 90 91 92 93 94 95
::node[id=__changelog type=meta] ::changelog 2025-04-15|added |node[kubernetes-deploy]|New k8s support added 2025-04-10|updated |node[install] |--break-system-packages flag 2025-03-01|deprecated|node[heroku-deploy] |Heroku free tier ended ::end ::end # __changelog
12