Thinking in Agentic Primitives

Resources

• Kody’s capability layer — Kody’s own usage documentation maps packages, shared memory, secrets, jobs, workflows, and execution boundaries behind a compact MCP interface. It is a concrete system to inspect when shifting from service-specific integrations to reusable primitives that an agent can compose. https://github.com/kentcdodds/kody/blob/main/docs/use/index.md

• Code Mode — Cloudflare’s engineering article presents tool interfaces as a TypeScript API that an agent can call through generated code. Use it to discuss composition, data processing outside the context window, and the runtime boundary that must constrain generated programs. https://blog.cloudflare.com/code-mode/

• A virtual shell and filesystem — Vercel’s just-bash package documents a simulated shell, an in-memory filesystem, custom commands, network configuration, and execution limits. Its separation of per-call shell state from shared files makes execution surfaces and storage lifetimes tangible without equating a virtual filesystem with unrestricted host access. https://github.com/vercel-labs/just-bash/tree/main/packages/just-bash

• Workflows as durable programs — Temporal explains workflow execution through event history and replay, including recorded timers and external results. This gives tasks, waits, and resumable state transitions an operational meaning beyond a sequence of prompts. https://docs.temporal.io/workflows

• Activities isolate external operations — Temporal’s Activity documentation separates orchestration from operations such as API calls, database writes, and LLM requests. Its guidance on idempotency and recovery is useful for showing why deterministic workflow code does not make external side effects automatically safe. https://docs.temporal.io/activities

• Queues separate work from workers — Temporal describes task queues as the routing and load-balancing boundary between scheduled work and available workers. Use its persistence, throttling, and ordering details to reason about jobs, worker capacity, and backpressure rather than assuming every task should execute immediately. https://docs.temporal.io/task-queue

• Graphs are state plus transitions — LangGraph’s Graph API defines state schemas, nodes, edges, reducers, and conditional routing. It is an explicit representation for decomposing agent behavior into operations and transitions, including how concurrent updates combine. https://docs.langchain.com/oss/python/langgraph/graph-api

• Permissions are runtime policy — Deno documents explicit filesystem, network, environment, and process permissions, including permissions that bypass its sandbox. Use it to distinguish a capability’s declared scope from effective authority and to explain why untrusted generated code needs additional isolation. https://docs.deno.com/runtime/fundamentals/security/

• Usage accounting for agent budgets — OpenAI exposes aggregate and per-request usage through the run context. This supplies the accounting inputs for application-enforced token or cost budgets, while making clear that observing usage is not itself a hard spending limit. https://openai.github.io/openai-agents-python/usage/

• Schemas make contracts inspectable — The JSON Schema reference explains how to constrain object structure, required fields, values, and reusable definitions. Use it for task inputs, operation results, and artifact metadata, while distinguishing structural validity from a correct or authorized outcome. https://json-schema.org/understanding-json-schema/reference

• Guardrails have execution boundaries — OpenAI documents input, output, and tool guardrails, their tripwires, and where they apply during a run. This helps locate checks around specific operations rather than treating one generic safety prompt as a system-wide guarantee. https://openai.github.io/openai-agents-python/guardrails/

• Approval is a resumable state transition — OpenAI’s human-in-the-loop guide shows how tool approval interrupts execution and how serialized run state can resume after a decision. It provides a concrete primitive for granting narrowly scoped authority at the moment a side effect is proposed. https://openai.github.io/openai-agents-python/human_in_the_loop/

• Provenance as an execution receipt — SLSA’s provenance specification records build inputs, dependencies, builder identity, invocation metadata, and output artifacts. Although designed for software supply chains, it is a useful reference for designing receipts for generated packages without confusing traceability with proof of correctness. https://slsa.dev/spec/v1.1/provenance

• Promoting a capability through tests and review — Anthropic’s Skill Creator includes test prompts, quantitative checks, human review, comparison runs, and iterative improvement of reusable skills. Use it as a concrete promotion loop: extract repeated work into an artifact, evaluate it, and review it before broader reuse. https://github.com/anthropics/skills/tree/main/skills/skill-creator