{ "schema": "https://miscsubjects.com/schemas/jarticle.json", "status": "published", "slug": "atomic-tooling", "title": "Atomic tooling: one tool per domain, the orchestration inside it, and a model that only has to say what it wants", "kind": "architecture", "summary": "Most of an agent's tool calls are plumbing: read a file, hash it, write it, re-read it, retry a search, page a result. The industry's answer is to let the model write code that does the plumbing in a sandbox. This system takes the opposite route: one tool per domain whose arguments carry a command and its complications, with the fallbacks, verification, hashing and result budgeting built into the tool. The model declares; the runtime executes, bounds and records. Five such tools are live. Here is what they do, how they compare to programmatic tool calling, and what is still missing.", "tags": [ "architecture", "ai-agents", "tool-design", "programmatic-tool-calling", "mcp", "context-engineering" ], "facts": { "measured_at": "2026-10-09T05:10:00Z", "built_and_live": [ { "tool": "CODE", "ops": [ "schema", "grep", "read", "edit", "write", "check", "grammar", "deploy", "ship", "job", "result" ], "ops_count": 11, "properties": [ "reads return the canonical hash; changing an existing file requires base_hash and is refused on a stale hash", "tests, deploys and ships run as detached jobs; job reports status, result retrieves evidence", "deterministic operations; no model planner", "return.select, return.max_bytes, return.mode; the whole result stays at full_ref" ], "call_forms": 30 }, { "tool": "WEB", "ops": [ "schema", "search", "read", "sites", "discover", "result" ], "ops_count": 6, "properties": [ "internal search, Safari and Alfred reads on the owner's Mac", "declared fallback across sources and literal verification of what it returns", "complete results stored before a selectable return budget", "no model is called" ] }, { "tool": "COMPUTER", "ops": [ "schema", "see", "run", "map", "result" ], "ops_count": 5, "properties": [ "browser procedures on an isolated persistent browser on the owner's Mac", "a run accepts steps or conditional rules, label or role targets, done_when and verify", "acts and verifies internally without model round trips", "returns done, ambiguous, target_missing, needs_plan, stalled or transition_failed with a graph and receipts", "no model calls, no confidence scores, no autonomous planner, no screenshots, no native desktop control" ] }, { "tool": "RESULT", "ops": [ "{call_id}", "{call_id, grep}", "{call_id, from, to}", "{call_id, json}", "{grep}", "{tail}" ], "properties": [ "reads back any earlier call from the Ledger and returns only the part asked for", "every answer states the whole payload's size and the bytes returned", "read-only; writes nothing; calls no model" ] }, { "tool": "ARTICLE", "ops": [ "schema", "list", "read", "at", "grep", "create", "replace", "patch", "delete", "verify", "publish", "comment", "cli", "theme", "theme_patch", "models", "result" ], "ops_count": 17, "properties": [ "reads answer the hash; changes need it", "publish = write, fetch and hash every source, set published only when every quote is found, one call", "return.select and return.max_bytes; the whole result stays at full_ref" ] } ], "designed_not_built": [ { "tool": "REST", "shape": "{api, command, body, complications: {headers, query, auth, retry, return}}", "what": "one tool for every HTTP API; the runtime holds each API's contract and the stored credential" }, { "tool": "SEARCH escalation", "shape": "{q, complications: {escalate: [directory, ledger, web, apis], max_bytes}}", "what": "one search that climbs from the local catalog to the web to connected APIs instead of failing silently at the first source" }, { "tool": "MAC unification", "shape": "{surface: shell | applescript | alfred | ax | keychain | gui, command, complications: {cwd, timeout, evidence}}", "what": "the Mac tools that exist today as separate rows, behind one contract with a surface complication" }, { "tool": "SQL guardrails", "shape": "{q, complications: {timeout_s, max_rows, explain_first}}", "what": "a statement timeout and a row cap enforced by the door, not remembered by the model" } ], "return_contract": { "select": "dot paths into the result", "max_bytes": "a budget cut at whole records or whole fields, never mid-field", "mode": [ "selected", "full", "reference" ], "full_ref": "{tool, args: {op: 'result', ref}} retrieves the whole stored result without re-running anything", "every_answer_states": "original size, returned size, whether anything was omitted" }, "catalog_projection": { "with_descriptions_bytes": 817371, "names_only_bytes": 41663, "ratio": 19.6, "tools": 1582 }, "industry_reference_points": { "anthropic_programmatic_tool_calling": "the model writes code that calls tools inside a container; intermediate results stay out of context; documented saving: roughly 38% fewer billed input tokens on a 75-tool benchmark with no change in accuracy", "anthropic_code_execution_with_mcp": "tools presented as code on a filesystem so the model loads definitions on demand", "anthropic_tool_search": "the model searches a catalog and loads only the tools it needs", "openai_function_calling": "function definitions count against the context limit and are billed as input tokens; deferred loading and a tool-search tool offered" }, "side_by_side": [ { "axis": "who writes the logic", "programmatic_tool_calling": "the model, as code", "atomic_tooling": "nobody at call time; the runtime already encodes it" }, { "axis": "the model's job", "programmatic_tool_calling": "program, debug, interpret", "atomic_tooling": "choose a tool, a command and its complications" }, { "axis": "determinism", "programmatic_tool_calling": "none; model code can do anything the sandbox allows", "atomic_tooling": "total; hash-checked, bounded, receipted" }, { "axis": "sandbox required", "programmatic_tool_calling": "yes", "atomic_tooling": "no" }, { "axis": "coverage", "programmatic_tool_calling": "anything code can do", "atomic_tooling": "the declared surface of each tool" }, { "axis": "failure mode", "programmatic_tool_calling": "buggy model code, runaway loops", "atomic_tooling": "a refused declaration (stale hash, unknown argument, over budget)" }, { "axis": "evidence", "programmatic_tool_calling": "whatever the code logs", "atomic_tooling": "automatic: full result stored, Ledger rows, full_ref" }, { "axis": "novel algorithms", "programmatic_tool_calling": "yes", "atomic_tooling": "only through a complication that exists" } ], "series": [ "directory-ledger-pattern", "unified-dispatch-macaroon-atoms", "atomic-tooling", "task-payload-provenance-article" ] }, "card_fields": [ "built_and_live.0.tool", "built_and_live.0.ops_count", "return_contract.mode", "catalog_projection.ratio" ], "ontology": { "above": [ "directory-ledger-pattern" ], "below": [], "adjacent": [ "unified-dispatch-macaroon-atoms", "task-payload-provenance-article", "compound-tools-vs-programmatic-tool-calling", "tooling-as-data" ], "nested": [], "show_position": true }, "body": [ "## The waste this is built to remove\n\nWatch an agent edit a file. It runs a shell command to print the file. It reads the output into its context. It composes the new contents. It writes them with another shell command. It prints the file again to check. Somewhere in there it should have checked that nobody else changed the file in between, and usually it did not. Five calls, several thousand tokens of file contents carried through the model twice, and a race condition.\n\nNow watch it search. It calls a search tool and gets a hundred results. It needs three. The other ninety-seven sit in its context for the rest of the conversation. If the search fails, it has to notice, decide on a fallback, and try again, spending reasoning on a decision the system could have made for it.\n\nNone of that is intelligence. It is plumbing, and the model is the most expensive and least reliable component in the system to do plumbing with. The question this article answers is where the plumbing should live instead.", "## The industry's answer: let the model write the plumbing\n\nThe vendors have converged on a clear pattern. Anthropic's **programmatic tool calling** lets the model write code that calls tools inside a container, so intermediate results never enter its context; the documentation describes it as a trade of [a small fixed overhead (container startup, script generation) for large savings on tool-result tokens and model round-trips](https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling), and reports that [on a 75-tool project-management agent benchmark, enabling programmatic tool calling reduced billed input tokens by roughly 38% with no change in task accuracy](https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling). Its engineering post on **code execution with MCP** diagnoses the two costs precisely: [most MCP clients load all tool definitions upfront directly into context](https://www.anthropic.com/engineering/code-execution-with-mcp), and in a plain tool loop [every intermediate result must pass through the model](https://www.anthropic.com/engineering/code-execution-with-mcp). OpenAI's documentation states the same economics: function definitions [count against the model's context limit and are billed as input tokens](https://platform.openai.com/docs/guides/function-calling). Both now offer deferred tools and a tool-search tool so the model can [search the tool catalog instead of loading all tool definitions up front](https://docs.claude.com/en/docs/agents-and-tools/tool-use/tool-search-tool).\n\nThese are real improvements and the diagnosis is correct. But notice what programmatic tool calling asks for. The model becomes the programmer. It writes the loop, the filter, the retry and the error handling, in code that has to be generated, debugged and sandboxed, and whose evidence of what ran is whatever that code chose to log. The same post admits the bill: a sandbox and its [infrastructure requirements add operational overhead and security considerations that direct tool calls avoid](https://www.anthropic.com/engineering/code-execution-with-mcp). The intelligence has been pushed *into* generated code. The plumbing is still done fresh each time, now in a language the model had to write.", "## This system's answer: one tool per domain, the plumbing inside it\n\n**Atomic tooling** pulls in the opposite direction. For each domain there is one tool. Its arguments carry a **command** (which operation) and **complications** (the modifiers that shape it: what to return, how many bytes, which stored credential, whether to retry, what counts as done). The runtime compiles the declaration into the real calls, performs the fallbacks and the verification, stores the whole result, and hands back only the slice that was asked for, with a reference to the rest.\n\nIt is programmatic tool calling in reverse. Instead of the model writing code the sandbox must hold, the model writes a declaration the runtime can check, bound and record. The word \"atomic\" is meant literally: one call, one operation that either completes or is refused as a unit, with no intermediate state the model has to carry.\n\nThe idea is older than agents. The Unix rule was to [make each program do one thing well](https://en.wikipedia.org/wiki/Unix_philosophy) and compose; an atomic tool is one domain done well, with composition declared in its arguments rather than scripted around it. Anthropic's own survey of what works in production reached a compatible conclusion: [the most successful implementations weren't using complex frameworks or specialized libraries. Instead, they were building with simple, composable patterns](https://www.anthropic.com/research/building-effective-agents).", "## Five atomic tools, live\n\n**CODE: one coding tool, eleven operations.** `schema · grep · read · edit · write · check · grammar · deploy · ship · job · result`. A read returns the file and its canonical hash. Changing an existing file requires that hash as `base_hash`, and an edit against a stale hash is refused rather than applied; the runtime owns the truth about what the file currently is. Tests, deploys and ships run as detached jobs: the call returns a job id and receipts, not a blocked session, and `job` and `result` fetch status and evidence later. There is no model planner inside it. The five-call edit loop from the opening becomes one call: `{op: \"edit\", path, base_hash, edits}`.\n\n**WEB: one internet tool.** `search · read · sites · discover · result`. It searches, reads pages and looks up sites with a declared fallback across sources and literal verification that what it returns is what the page said. Complete results are stored before a selectable return budget is applied. It calls no model. A failed source is the tool's problem to route around, not the caller's to notice.\n\n**COMPUTER: browser procedures without round trips.** `see · run · map · result`. A run is a list of steps or conditional rules with `done_when` and `verify` predicates, targeting controls by label or role. The tool acts and verifies internally on an isolated persistent browser on the owner's Mac, with no model called between steps, and returns a named outcome: `done`, `ambiguous`, `target_missing`, `needs_plan`, `stalled` or `transition_failed`, with a graph of what it saw and receipts of what it did. It takes no screenshots and has no autonomous planner; the caller declares the procedure, the tool executes it deterministically.\n\n**RESULT: read back a slice of anything.** Given a call id, it returns every row of that call, or only the lines matching a pattern (with line numbers and 120 characters of context), or a byte range to page through a large answer, or one value at a dotted JSON path. Given only a pattern, it scans the newest Ledger payloads to find the call id. Every answer states how many bytes the whole payload was and how many were returned, so nothing is cut silently. It is read-only and calls no model. This is the tool that makes \"ask for less\" safe: whatever was not shown can always be fetched.\n\n**ARTICLE: one tool for every article on this site.** Seventeen operations over the JSON article format this page is stored in. Reads answer the hash; changes need it. `publish` is the whole editorial flow in one call: write against the hash, fetch and hash every cited source, and set the article published only when every quote was found on its page. The article you are reading went through it.", "## The complication that ships everywhere: `return`\n\nFour of the five tools share one argument, and it is the seed of the whole pattern:\n\n```json\n\"return\": { \"select\": [\"results.0.url\", \"status\"], \"max_bytes\": 2000, \"mode\": \"selected\" }\n```\n\n`select` names dot paths into the result. `max_bytes` is a budget, applied at whole records or whole fields, never by cutting a string in the middle. `mode` is `selected`, `full` or `reference`. Whatever the model asked for, the **whole result is stored first**, and the answer carries a `full_ref`: a call that retrieves the stored result without running the tool again. Every answer also states the original size, the returned size and whether anything was omitted.\n\nThis is the same discipline the catalog uses. Every tool with its description is 817,371 bytes; every tool name alone is 41,663 bytes, 19.6 times smaller. A model reads names, then opens one row. Results work the same way: the model sees a projection; the system keeps the whole. Nothing is re-run to be re-read, and a reviewer can always retrieve what the model was not shown. The [[directory-ledger-pattern|Ledger]] holds every full result, and [[task-payload-provenance-article|a task's proof page]] can show any of them.", "## Side by side\n\n| | Programmatic tool calling | Atomic tooling |\n|---|---|---|\n| Who writes the logic | The model, as code | Nobody at call time; the runtime already encodes it |\n| The model's job | Program, debug, interpret | Choose a tool, a command and its complications |\n| Determinism | None; model code can do anything the sandbox allows | Total; hash-checked, bounded, receipted |\n| Cost per action | Model tokens per iteration of code generation | One small structured call |\n| Sandbox needed | Yes | No |\n| Coverage | Anything code can do | The declared surface of each tool |\n| Failure mode | Buggy model code, runaway loops | A refused declaration: stale hash, unknown argument, over budget |\n| Evidence | Whatever the code logs | Automatic: whole result stored, Ledger rows, `full_ref` |\n| Novel algorithms | Yes | Only through a complication that exists |\n\nThe honest ruling is that these are opposites, and both are right somewhere. Programmatic tool calling is the correct tool when the logic is genuinely novel and nobody has written it down. Anthropic's own documentation names the case where it does not pay: [strictly sequential workflows where each call depends on Claude reasoning over the previous result, because the script cannot skip the model round-trip in that case](https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling). Atomic tooling is the correct tool when the surface is known, which is most of what agents do all day. The two compose: an atomic tool should be able to say \"this surface is fully covered; do not write code\", and every piece of model-written code that recurs is a candidate to become a complication.", "## Why this matters for control, not only for cost\n\nToken savings are the visible benefit. The structural one is that **the model's action space becomes enumerable.** A declared command with declared complications is a finite set of things a model can ask for. That set can be bounded by a [[unified-dispatch-macaroon-atoms|scoped token]]'s argument rules (`arg CODE.path prefix /src/`), refused by the runtime when the declaration is wrong, and recorded by the runtime step by step rather than narrated by the model afterwards. A sandbox running model-written code offers none of those three properties by default; it has to be instrumented to approximate them.\n\nPut another way: programmatic tool calling asks how to make model-written code cheap and safe. Atomic tooling asks why the model is writing that code at all, and answers that for the known surfaces it should not be. What is left for the model is the part only it can do: deciding what the task needs.", "## What is designed and not yet built\n\nThe pattern was first built as a coding tool. The owner's observation, recorded in the build's own notes, is that it should have been built as the general shape for every domain. The remaining instances are specified:\n\n**REST: one tool for every HTTP API.** `{api: \"google.calendar\", command: \"events.insert\", body: {...}, complications: {headers, query, auth: \"google\", retry: {on: [429, 503], backoff: \"exp\"}, return: {...}}}`. The runtime holds each API's contract and the stored credential; the model never assembles a URL, an auth header or a pagination loop. Compare the current state of the art: one MCP tool per endpoint, each costing definition tokens in every prompt, or the model writing `fetch` code and debugging its own headers.\n\n**SEARCH escalation.** Today's local search looks in the Directory only. A search that fails silently when the answer is on the web or in a connected API is a dead end the model has to notice. Escalation (`complications: {escalate: [directory, ledger, web, apis]}`) belongs inside the one search tool, not in a second tool the model must remember exists.\n\n**MAC unification.** The Mac is reachable today through several separate tool rows: shell execution, file write, process list, the Claude Code CLI, AppleScript. One tool with a `surface` complication (`shell | applescript | alfred | ax | keychain | gui`) is the same move as REST, applied to a machine. A structured surface answers in tens of tokens, deterministically, where screenshot-and-click computer use spends a screenshot per step and guesses at pixels; pixels become a complication for verification (`evidence: screenshot`) rather than the primary channel.\n\n**SQL guardrails.** The lesson from this build's own database: a query door with no statement timeout and no row cap lets any model, on any task, issue an unbounded scan, and one did, repeatedly, until an index and a rewrite fixed it. Boundedness is a runtime guarantee (`complications: {timeout_s, max_rows, explain_first}`), not something to hope the model remembers.\n\nOrder of work, by value per line of code: search escalation first, then Mac unification, then REST with the Google surface, then the browser surfaces once audited. SQL guardrails are a small change to one door.", "## Where the design stops\n\n- Atomic tooling covers known surfaces. A genuinely novel procedure still needs code, and today that means a person or a programmatic-tool-calling fallback writes it.\n- COMPUTER drives a browser. It has no native desktop control and takes no screenshots; the Mac's other surfaces are separate tools until the unification above is built.\n- WEB and COMPUTER depend on the owner's Mac being reachable. A Directory row for them does not establish that the machine is awake.\n- The `return` contract runs inside four tools. The general envelope that would apply it at one door for every capability is designed, not implemented.\n- The side-by-side table is an analysis of properties, not a benchmark. The 38% figure is Anthropic's measurement of programmatic tool calling on its own benchmark; no equivalent controlled measurement of atomic tooling has been run here.\n\n## The rest of the series\n\n- [[directory-ledger-pattern|The Directory and the Ledger]]: the rows these tools are, and the record their full results go to.\n- [[unified-dispatch-macaroon-atoms|Unified dispatch]]: the one runner every atomic call crosses, and the token that can bound each argument.\n- [[task-payload-provenance-article|Task provenance]]: how a task's calls through these tools become a page a stranger can inspect." ], "sources": [ { "id": "s1", "url": "https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling", "title": "Claude Developer Platform: Programmatic tool calling", "publisher": "Anthropic", "source_type": "documentation", "quote": "Programmatic tool calling trades a small fixed overhead (container startup, script generation) for large savings on tool-result tokens and model round-trips.", "quote_sha256": "1f201cdf825f13908ac3ec557289593689cc84f9e1a58671b38d0d91e2fac891", "http_status": 200, "snapshot_sha256": "25d74a9ef88a0f57f0babcff74a9367eaee5aa9466139ad188076c4bf9098b56", "snapshot_bytes": 1580640, "quote_found": true, "verified_at": "2026-10-09T04:18:12.021Z" }, { "id": "s2", "url": "https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling", "title": "Programmatic tool calling: the measured saving", "publisher": "Anthropic", "source_type": "documentation", "quote": "On a 75-tool project-management agent benchmark, enabling programmatic tool calling reduced billed input tokens by roughly 38% with no change in task accuracy.", "quote_sha256": "f3bc21cd0d62e3edff34204ca24ac6ad4e8ea084c83f7a730fb23f8ee047f9dd", "http_status": 200, "snapshot_sha256": "db039365d44bbac823feb8020e25855c6fa24bd928387afa92e76a916ecce6c8", "snapshot_bytes": 1580640, "quote_found": true, "verified_at": "2026-10-09T04:18:11.845Z" }, { "id": "s3", "url": "https://docs.claude.com/en/docs/agents-and-tools/tool-use/programmatic-tool-calling", "title": "Programmatic tool calling: where it does not pay", "publisher": "Anthropic", "source_type": "documentation", "quote": "Strictly sequential workflows where each call depends on Claude reasoning over the previous result, because the script cannot skip the model round-trip in that case", "quote_sha256": "bd31cfcd6906560f918508cefcdb507608c4ef12fbfc954e012131a2985cbd02", "http_status": 200, "snapshot_sha256": "b8503dccb7b65d70c56f9cd48bd3b1c454df77ad13de091fab17f8e93f420e66", "snapshot_bytes": 1580640, "quote_found": true, "verified_at": "2026-10-09T04:18:11.845Z" }, { "id": "s4", "url": "https://www.anthropic.com/engineering/code-execution-with-mcp", "title": "Code execution with MCP", "publisher": "Anthropic", "source_type": "article", "quote": "Most MCP clients load all tool definitions upfront directly into context", "quote_sha256": "ed6e8b1978b1cbcf5547fccae04e098b3f57739af652c1af78bc240a48cd9f79", "http_status": 200, "snapshot_sha256": "9bfd99dcbe06f90ce17b56c60cfd340824936b2326819ce879caf59ae518fd1a", "snapshot_bytes": 174220, "quote_found": true, "verified_at": "2026-10-09T04:18:11.649Z" }, { "id": "s5", "url": "https://www.anthropic.com/engineering/code-execution-with-mcp", "title": "Code execution with MCP: every intermediate result", "publisher": "Anthropic", "source_type": "article", "quote": "Every intermediate result must pass through the model.", "quote_sha256": "568cfce64bafc0b21c7d6b359c8a5c4b045c14f5473cf5093ac9d8d00eb6fe42", "http_status": 200, "snapshot_sha256": "9bfd99dcbe06f90ce17b56c60cfd340824936b2326819ce879caf59ae518fd1a", "snapshot_bytes": 174220, "quote_found": true, "verified_at": "2026-10-09T04:18:11.655Z" }, { "id": "s6", "url": "https://www.anthropic.com/engineering/code-execution-with-mcp", "title": "Code execution with MCP: the cost of a sandbox", "publisher": "Anthropic", "source_type": "article", "quote": "These infrastructure requirements add operational overhead and security considerations that direct tool calls avoid.", "quote_sha256": "67335ab24c7b966cf1a84540f9f7aff8e558a72980d793370386a8181dfdc29b", "http_status": 200, "snapshot_sha256": "9bfd99dcbe06f90ce17b56c60cfd340824936b2326819ce879caf59ae518fd1a", "snapshot_bytes": 174220, "quote_found": true, "verified_at": "2026-10-09T04:18:11.633Z" }, { "id": "s7", "url": "https://docs.claude.com/en/docs/agents-and-tools/tool-use/tool-search-tool", "title": "Claude Developer Platform: Tool search tool", "publisher": "Anthropic", "source_type": "documentation", "quote": "Instead of loading all tool definitions into the context window up front, Claude searches your tool catalog", "quote_sha256": "6e78ff92e0532f055a09625befe1524c1a61502d1ab19ee028613a27b359aca1", "http_status": 200, "snapshot_sha256": "3bb793a0ad302b1fd477efde26866c8c1affffe74384393e2c67f893c5fe109d", "snapshot_bytes": 1103675, "quote_found": true, "verified_at": "2026-10-09T04:18:11.845Z" }, { "id": "s8", "url": "https://docs.claude.com/en/docs/agents-and-tools/tool-use/tool-search-tool", "title": "Tool search tool: why selection degrades", "publisher": "Anthropic", "source_type": "documentation", "quote": "Because tool search loads only a focused set of relevant tools on demand, selection accuracy stays high even across thousands of tools.", "quote_sha256": "ef2c7d4734507c2e085eeb7dbf21a36ef8ba797550ce29abae8f5ee096e82f91", "http_status": 200, "snapshot_sha256": "99e95545bd664027e2810a8f4381ea8b20bffef14fce5289c7aebacb290a76c6", "snapshot_bytes": 1103675, "quote_found": true, "verified_at": "2026-10-09T04:18:11.773Z" }, { "id": "s9", "url": "https://platform.openai.com/docs/guides/function-calling", "title": "OpenAI: Function calling", "publisher": "OpenAI", "source_type": "documentation", "quote": "callable function definitions count against the model’s context limit and are billed as input tokens", "quote_sha256": "39624dcf42f53a7a7cccc9fee7f9d925d9b1b5d10d7b5b920fcc8143f66fab1c", "http_status": 200, "snapshot_sha256": "5e5d0784aa04939e46631f1d542fec94917cf5beef38032c54c07b0c1809f8ca", "snapshot_bytes": 1469183, "quote_found": true, "verified_at": "2026-10-09T04:18:11.698Z" }, { "id": "s10", "url": "https://en.wikipedia.org/wiki/Unix_philosophy", "title": "Unix philosophy", "publisher": "Wikipedia", "source_type": "encyclopedia", "quote": "Make each program do one thing well.", "quote_sha256": "d64804bd37ff30be89f969b12d5529294134722112c1673c23c0e03588f1417f", "http_status": 200, "snapshot_sha256": "d060fe13f3aba83ed42fb6341f19033f70c574212e4ceab529ad3f5f2b671798", "snapshot_bytes": 189439, "quote_found": true, "verified_at": "2026-10-09T04:18:11.646Z" }, { "id": "s11", "url": "https://www.anthropic.com/research/building-effective-agents", "title": "Building effective agents", "publisher": "Anthropic", "source_type": "article", "quote": "Instead, they were building with simple, composable patterns.", "quote_sha256": "49b37da849c80265a3e33800892da5fb6480baf675c59f1269141cfe68ad3f0a", "http_status": 200, "snapshot_sha256": "a9f34f8e8471f70c1511ce2f55e55b8b68be2a398e5b893c16a9723bec7f2133", "snapshot_bytes": 174546, "quote_found": true, "verified_at": "2026-10-09T04:18:11.727Z" }, { "id": "s12", "url": "https://modelcontextprotocol.io/specification/2025-06-18/server/tools", "title": "Model Context Protocol: Tools", "publisher": "Model Context Protocol", "source_type": "specification", "quote": "The Model Context Protocol (MCP) allows servers to expose tools that can be invoked by language models.", "quote_sha256": "e6c355ddc14f05c03a4cf5f6ae689d310aec8d2e5279748a7b4215d2159bde9b", "http_status": 200, "snapshot_sha256": "22530615115b4af6102dd3e69a119b5d79b2c9f2d676cec3572d0c7ae34ea58b", "snapshot_bytes": 535555, "quote_found": true, "verified_at": "2026-10-09T04:18:11.664Z" }, { "id": "s13", "url": "https://miscsubjects.com/a/scoped-access", "title": "Scoped access: the page the build writes from its own code", "publisher": "miscsubjects", "source_type": "primary", "quote": "Every capability of this build runs through one dispatch authority. A scoped token is a link-sized string that carries its own limits: which tools, by which doors, how many times, until when, for which task, inside which folders, for whom.", "quote_sha256": "257f6287e22a3fce3a48301dbae14936a420009636ecb4095aa78e4c96b7b0af", "http_status": 200, "snapshot_sha256": "8edaa9f54a465d78eef6f54d9c03224367ee92ad599a0e1161bfeb3e104df35f", "snapshot_bytes": 53854, "quote_found": true, "verified_at": "2026-10-09T04:18:11.633Z" } ], "comments": [], "type": "article", "created": "2026-10-09T04:17:31.834Z", "updated": "2026-10-09T04:18:14.034Z", "version": 5, "hash": "7daacfda912d60c556f376cba936eab8101ce61fa45f3ef915537817a0d5052b", "styling": { "scope": "shared", "how": "no value on the page is set by hand: each comes from this theme, and each theme value becomes the CSS variable named beside it. PATCH https://miscsubjects.com/api/jarticles/theme changes them.", "widget_style": { "what": "every widget may carry style: {…}; these are the only keys it reads", "rotate": "degrees, a number", "offset_x": "pixels, a number", "offset_y": "pixels, a number", "pulse": "true to pulse" }, "theme": { "color": { "page_bg": "#f5f5f7", "sheet_bg": "#ffffff", "ink": "#1d1d1f", "soft": "#424245", "muted": "#6e6e73", "dim": "#86868b", "line": "#d2d2d7", "accent": "#0071e3", "accent_soft": "rgba(0,113,227,0.08)", "link": "#0066cc", "selection": "rgba(0,113,227,0.18)", "widget_bg": "#f5f5f7", "widget_border": "#d2d2d7", "card_bg": "#ffffff", "code_bg": "#f5f5f7", "json_bg": "#161b19", "json_ink": "#e6e1d4", "json_key": "#7fd3c3", "json_string": "#e9c46a", "json_number": "#f4a261", "json_bool": "#c792ea", "json_null": "#928d7e", "json_punct": "#6b6759", "json_bar": "#0e1512", "kind_badge_bg": "#0e6e60", "kind_badge_ink": "#ffffff" }, "color_dark": { "page_bg": "#000000", "sheet_bg": "#1d1d1f", "ink": "#f5f5f7", "soft": "#d2d2d7", "muted": "#a1a1a6", "dim": "#86868b", "line": "#424245", "accent": "#2997ff", "accent_soft": "rgba(41,151,255,0.12)", "link": "#2997ff", "selection": "rgba(41,151,255,0.25)", "widget_bg": "#2c2c2e", "widget_border": "#424245", "card_bg": "#1d1d1f", "code_bg": "#2c2c2e", "json_bg": "#0a0d0c", "json_ink": "#e6e1d4", "json_key": "#7fd3c3", "json_string": "#e9c46a", "json_number": "#f4a261", "json_bool": "#c792ea", "json_null": "#757062", "json_punct": "#5d665f", "json_bar": "#060807", "kind_badge_bg": "#4fc1ab", "kind_badge_ink": "#0b0f0d" }, "font": { "display": "-apple-system,BlinkMacSystemFont,\"SF Pro Display\",\"SF Pro Text\",\"Helvetica Neue\",Helvetica,Arial,sans-serif", "body": "-apple-system,BlinkMacSystemFont,\"SF Pro Display\",\"SF Pro Text\",\"Helvetica Neue\",Helvetica,Arial,sans-serif", "mono": "ui-monospace,SFMono-Regular,\"SF Mono\",Menlo,Consolas,monospace", "google_fonts": "" }, "size": { "body": "17px", "small": "17px", "eye": "17px", "lead": "17px", "h1": "52px", "h2": "34px", "h3": "22px", "byline": "17px", "h1_measure": "none", "code": "17px", "json": "17px", "widget_title": "17px" }, "leading": { "body": "1.7", "head": "1.18", "lead": "1.5", "json": "1.6" }, "weight": { "display": "700", "head": "700", "body": "400", "strong": "700", "eye": "700" }, "tracking": { "eye": "0.14em", "display": "-0.03em", "body": "-0.006em", "badge": "0.08em" }, "layout": { "sheet_width": "1000px", "text_width": "880px", "gutter": "16px", "sheet_padding": "56px 64px 64px", "sheet_padding_mobile": "24px 18px 40px", "sheet_margin": "28px auto 72px", "block_gap": "1.15em", "widget_gap": "28px", "grid_gap": "14px" }, "border": { "sheet": "0px solid", "sheet_radius": "30px", "widget": "1px solid", "widget_radius": "24px", "card_radius": "24px", "badge_radius": "999px", "rule": "1px solid", "code_radius": "18px", "accent_bar": "3px" }, "shadow": { "sheet": "0 1px 1px rgba(0,0,0,.02),0 6px 26px rgba(0,0,0,.05)", "widget": "none", "card_hover": "0 10px 28px -16px rgba(28,27,23,0.35)" }, "motion": { "hover": "160ms ease" } } }, "page": "https://miscsubjects.com/a/atomic-tooling", "json": "https://miscsubjects.com/a/atomic-tooling.json", "markdown": "https://miscsubjects.com/a/atomic-tooling.md", "theme": "https://miscsubjects.com/article-theme.json", "calls": [ { "what": "this article as a page (no key)", "method": "GET", "url": "https://miscsubjects.com/a/atomic-tooling", "headers": {} }, { "what": "this article as its object (no key)", "method": "GET", "url": "https://miscsubjects.com/a/atomic-tooling.json", "headers": {} }, { "what": "this article as Markdown (no key)", "method": "GET", "url": "https://miscsubjects.com/a/atomic-tooling.md", "headers": {} }, { "what": "the object with its hash, drafts too", "method": "GET", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)" } }, { "what": "one piece and that piece’s hash", "method": "GET", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling/at?path=facts", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)" } }, { "what": "grep: every key or value that matches, with the path to change it", "method": "GET", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling/grep?q=owner", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)" } }, { "what": "change pieces (set, merge, delete, append, insert, move); if-match is the hash", "method": "PATCH", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)", "content-type": "application/json", "if-match": "" }, "body": { "ops": [ { "op": "set", "path": "facts.example", "value": 1 } ] } }, { "what": "replace the whole object", "method": "PUT", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)", "content-type": "application/json", "if-match": "" }, "body": { "slug": "atomic-tooling", "title": "…" } }, { "what": "fetch every source, hash what came back and check the quote is in it", "method": "POST", "url": "https://miscsubjects.com/api/jarticles/atomic-tooling/verify", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)", "content-type": "application/json" }, "body": {} }, { "what": "an Obsidian-style command", "method": "POST", "url": "https://miscsubjects.com/api/jarticles/cli", "headers": { "x-sheets-key": "$(cat /Users/cyrusmassoumi/.misc-sheets-key)", "content-type": "application/json" }, "body": { "command": "backlinks", "file": "atomic-tooling" } } ] }