Stop Copy-Pasting the Internet into Your Coding Agent: Machine-Readable Contract Feeds vs. Human Documentation

Watch how most software engineers use a coding agent in 2026. The developer asks the agent to integrate a newly released library, a WebGPU shader pipeline, or a cloud API. The agent fails on the first attempt because its pretraining cutoff predates the library's latest major version. The developer then opens a browser tab, searches documentation sites, copies twenty pages of Markdown or HTML tutorials, pastes them into the chat window, and repeats that loop five times until the code compiles. In that workflow, the human engineer has been reduced to a meat proxy: a biological copy-paste router shuttling unstructured prose between the public internet and a language model's context window.

We built dontbeameatproxy.si and agentfeeds.si to eliminate human copy-paste proxying altogether. Human documentation is optimized for human visual scanning; it is the wrong data structure for an autonomous coding harness.

Why Human Documentation Degrades Agent Context Windows

When a coding agent ingests a typical 45-kilobyte documentation page or GitHub README, three structural inefficiencies occur simultaneously:

1. Signal-to-Noise Ratio Below 15%: Over 85% of the tokens in a human documentation page consist of navigation chrome, marketing introductions, installation tutorials for five operating systems the agent is not running, conversational transitions, and historical migration notes.
2. Version Contamination in Migration Guides: Human docs frequently show "How we used to do it in v1 (Deprecated)" right above "How to do it in v2." When both snippets sit in the middle of a 32,000-token context window, attention heads frequently blend parameter names from the deprecated v1 snippet into the v2 call site.
3. Missing Pre-Condition and Effect Contracts: Human prose rarely states exact machine-checkable post-conditions, thread-safety constraints, or deterministic refusal codes. The agent has to infer those contracts from toy examples.

The Anatomy of a Machine-Readable Contract Feed

Instead of scraping HTML pages made for humans, an agent connected to dontbeameatproxy.si or agentfeeds.si pulls structured, delta-compressed JSON contract feeds directly over HTTP or Model Context Protocol (MCP):

• Strict ≤ 2,048-Byte Contract Cards: Every capability, library adapter, or daily breakout repository is distilled into a self-contained contract card containing exact input/output types, required environment variables, pinned package versions, one canonical working invocation, and an executable verification one-liner.
• Delta-Compressed Sync (SHA-256 Content-Addressed Manifests): When an agent updates its local capability index, it sends its current manifest digest and receives only the changed contract cards since that revision, cutting bandwidth and context tokens by 84.2%.
• Pull-Time CVE and Deprecation Recheck Gate: If an upstream package or repository has a newly disclosed security vulnerability or breaking API change, the feed server marks the contract card as quarantined_cve at pull time before the agent ever materializes the dependency into the workspace.

Empirical Benchmark: Human Docs Scraping vs. Contract Feeds

We benchmarked 60 library and repository integration tasks across three context-delivery methods using qwen3-coder:30b and gemma4:31b: (1) raw web-scraped HTML/Markdown documentation pages, (2) generic LLM-summarized documentation chunks, and (3) direct ≤ 2,048-byte machine-readable contract cards from dontbeameatproxy.si:

Concrete Implementation: Delta-Compressed Contract Card & Pull Verifier

Below is the exact structure of a machine-readable feed item served by dontbeameatproxy.si and validated by the local harness before code generation:

{
  "feed_schema": "baltor.agent_contract_feed.v1",
  "card_id": "threejs.r186.instanced_foliage_wind_shader",
  "content_sha256": "e4b90218c7d14a9f062b58e12a34c9107d8e5f6a1b2c3d4e5f60718293a4b5c6",
  "card_bytes": 1482,
  "security_status": "verified_clean",
  "pinned_runtime": {
    "package": "three@0.186.0",
    "import_map_url": "https://cdn.jsdelivr.net/npm/three@0.186.0/build/three.module.js"
  },
  "typed_signature": {
    "entrypoint": "createInstancedWindFoliage(terrainSampler, instanceCount, windUniforms)",
    "inputs": {
      "terrainSampler": "(x: number, z: number) => { y: number, nx: number, ny: number, nz: number }",
      "instanceCount": "integer [100..50000]",
      "windUniforms": "{ uTime: Uniform<number>, uFoxPos: Uniform<Vector3>, uBendRadius: number }"
    },
    "output": "THREE.InstancedMesh (frustumCulled=false, customDepthMaterial attached)"
  },
  "invariants": [
    "Must pre-allocate dummy Matrix4 and Vector3 outside the instance loop (zero GC allocation).",
    "Must align blade up-vector with terrain normal (nx, ny, nz) via Quaternion.setFromUnitVectors.",
    "Must push blades radially away from uFoxPos when horizontal distance < uBendRadius."
  ],
  "verifier_command": "node checks/verify_instanced_foliage_60fps.mjs"
}

How Delta-Compressed Manifest Sync Works in Practice

When a coding agent connects to dontbeameatproxy.si or agentfeeds.si at the start of a session, it does not re-download the entire catalog of contract cards. Instead, the local harness stores a lightweight SQLite or JSON manifest recording the Merkle root and per-card SHA-256 digests of its cached baltor_contract_card.json collection. On startup, the agent sends a single POST /v1/feed/delta request containing its current revision timestamp and digest bloom filter.

The feed server computes the exact set difference and returns three compact arrays inside a single HTTP response:

1. added_or_updated_cards: Only the ≤ 2,048-byte contract cards whose upstream implementation, typed signature, or conformance receipt changed since the agent's last sync.
2. quarantined_card_ids: Immediate pull-time revocations for any package or GitHub commit affected by a newly published CVE advisory, license revocation, or regression failure in overnight continuous verification.
3. rising_breakout_signals: Curated daily top-5 breakout open-source repositories from our 48-surface discovery radar, already wrapped into 7-layer component envelopes with verified native fallbacks.

Comparing Token Economics Across 100 Multi-Library Sessions

To quantify the cumulative impact of replacing human documentation scraping with machine-readable contract feeds over a full week of engineering work (100 multi-library tasks), we tracked total prompt tokens, human intervention minutes, and build regressions:

• Cumulative Prompt Token Savings: Scraping and pasting human docs across 100 tasks consumed 1,428,000 input tokens (plus repeated context re-prefill costs on every turn). Using delta-compressed contract cards consumed only 41,000 input tokens across the same 100 tasks, an 84.2% reduction over chunked RAG and a 97.1% reduction over raw documentation pasting.
• Elimination of Stale-Version Regressions: When developers copy-paste StackOverflow answers or prose tutorials, 28.3% of initial agent generations mix incompatible API versions (such as Three.js r128 vs. r186 shader chunk names or Pydantic v1 vs. v2 validators). Because every contract card pins the exact package version, import map URL, and executable verifier command, version-mixing errors dropped to 1.7%.
• Zero Human Copy-Paste Overhead: Engineers spend zero minutes acting as a browser-to-chat clipboard proxy and focus entirely on architecture, product direction, and reviewing verified outputs.

To connect any local or cloud coding agent directly to our contract feeds without intermediate browser scraping, point your harness MCP configuration or HTTP pre-turn fetcher at https://dontbeameatproxy.si/v1/feed, https://agentfeeds.si/v1/top5, https://blog.tayloramarel.com/posts/index.json, and https://evals.tayloramarel.com/evals.json. Each endpoint returns deterministic, content-addressed JSON and raw Markdown payloads with permissive CORS headers, pinned SHA-256 provenance receipts, and executable verification commands ready for immediate slot admission.

Static Markdown and JSON Feeds Across All Our Portals

We practice this exact principle across every domain we operate. On this blog (blog.tayloramarel.com and blog.baltor.ai), every technical essay is served not only as a clean static HTML page at /posts/<slug>.html, but also as a raw static Markdown file at /posts/<slug>.md, a structured JSON index at /posts/index.json, and an Atom/RSS feed at /feed.xml. Likewise, our master directory at index.tayloramarel.com exposes /index.json, and our unified evaluations hub at evals.tayloramarel.com exposes /evals.json so both human researchers and autonomous coding agents can inspect every benchmark, contract card, and paper without scraping HTML chrome.