Attribute as Contract: Why Trust Needs a File Path
Trust in agent systems gets much stronger when every important claim points to a durable artifact instead of a vague memory.
Latest
Published writings
Trust Is a Control Surface, Not a Binary: Hybrid vs Decentralized Agent Systems
Decentralization is often sold as a virtue in itself. In agent systems, the useful question is narrower: what should be shared, what should
Vibes Live on in Agentic
The word “vibes” has been used to mean everything and nothing. In some rooms it means mood, in others it means taste, and in too many produc
Cost and Step Budgets for Agent Work
When agent work gets expensive or wanders, the fix is often not a bigger model. It is a tighter budget on steps, branches, and retries.
Failure Postmortems Are an Operating System for Agent Teams
A good postmortem is not a ritual for blame. It is an operating loop that turns surprise into a smaller future surface area.
Multi-Agent Handoffs Need Receipts, Not Just Messages
Multi-agent systems fail less often when the handoff is treated like a product surface instead of an afterthought.
Using DistributedAgent Language for the First Time
I opened DistributedAgent Language the way most people open a new kitchen gadget: with confidence, a little fear, and absolutely no idea whe
Modular Agent Systems Need Better Boundaries
Modularity in agent systems is not mainly about splitting code into smaller files. It is about deciding which boundaries deserve to be real
Trust Profiles Are Built From Evidence, Not Vibes
A trust profile is not a personality trait. It is the record of what the system can prove, what it can explain, and what it can repeat.
On-Chain Verification for Agent Work: What Actually Needs to Be Proven
The fastest way to make agent work believable is not to add more model confidence. It is to attach each important step to a verifiable recor
Operator UX Is a Verification Problem
The fastest way to make an agent feel trustworthy is not to add more features; it is to make the operator’s next move obvious.
Verification Checkpoints: The Smallest Trust Primitive for Agent Work
Trust in agent systems gets stronger when every meaningful step leaves a proof the next run can inspect. Verification checkpoints make that
Evolve Memory Is Not a Notebook
Evolve memory works best when it stays selective. The point is not to remember everything; it is to remember what changes the next run.
Glue Scripts Are the Control Plane
The smallest reliable agent systems are usually not the ones with the most language. They are the ones with the fewest surprises.
Multi-Agent Handoffs Are a Control Surface, Not Just a Message
The hardest part of multi-agent systems is rarely model quality. It is handoff quality: what gets preserved, what gets lost, and who is allo
Route, Verify, Index: The Operating Loop That Makes Agents Feel Reliable
The most reliable agent workflows are not built on bigger prompts. They are built on a small loop: route the task, write the artifact, verif
Verification Checkpoints: How Agent Systems Turn Claims Into Proof
Agent systems get more trustworthy when every claim can point to a proof. The trick is making verification checkpoints cheap enough to use e
Verification Ledgers, Not Feelings
Verification is what keeps agent systems from turning confidence into surprise. The trick is not more intelligence; it is better proof.
Cost and Step Budgets: The Smallest Control That Makes Agent Work Predictable
When an agent is allowed to think forever, every task becomes a surprise. A budget for steps and a budget for cost turn that surprise into s
Failure Postmortems Are a Product Skill, Not a Ritual
The useful part of a failure postmortem is not blame; it is the shape of the next safe run.
Queue up Work in COO
COO is built around a simple promise: work should be easy to queue, easy to resume, and easy to verify.
File Handling in the DAL Standard Library
File handling is one of the most practical parts of programming, and the Dist Agent Language (DAL) standard library is designed to make it s
Shipping DAL: evolve memory, skills, and operator UX
Distributed Agent Language in COO is more than a vibe-coded chat wrapper around a language model. Our system is becoming a reliable operatin
The Quiet Power of Hub-and-Spoke Orchestration in Agent Systems
Hub-and-spoke orchestration is less about centralizing control and more about making coordination legible.
RAG Retrieval Tradeoffs: Latency, Recall, and the Cost of Surprise
RAG is not a single feature; it is a bundle of tradeoffs that decide whether an agent feels grounded or merely busy.
Self-Hosted Consoles Are About Control, Not Cosmetics
A self-hosted console is not just a dashboard. It is the place where scheduling, review, and execution become legible enough to trust.
Tool Loops Need Budgets, Not Just Brains
The fastest way to make an agent feel smart is to let it keep trying. The fastest way to make it reliable is to make every retry visible, bo
RAG + Tool Loops: When to Read the Repo vs When to Search
The best tool loops are not the ones with the most calls. They are the ones that choose the cheapest trustworthy source first, then verify o
Data Structures in the DAL Standard Library
The Dist Agent Language (DAL) standard library includes a small set of core data structures that cover most everyday programming tasks: list
Distributed Agent Language Technical Description
Distributed Agent Language (DAL) is a task-oriented language and runtime for coordinating agentic work across files, tools, workflows, and A
Trust-Bridge
Somewhere in **dist_agent_lang** there is a function whose job is to look at two strings and decide whether “centralized” and “decentralized
Trust-Split
**Trust-Split** in **dist_agent_lang** is not a pitch deck about “distributed consensus.” It is the observation that **one language** refuse
What is DAL?
DAL is a language and runtime for building tool-using agents that reason, act, and persist work in one loop—not a pile of one-off scripts.
iot.rs in DAL: the tiny file that knows too much
If DAL had a nervous system, `iot.rs` would be the part that keeps touching the stove, learning the lesson, and then writing a clean log abo
DAL skills and packages: how the system is organized
Skills and packages are how DAL stays modular—focused capability files and larger domain bundles instead of one giant prompt.
DAL Standard Library: an overview
The DAL standard library turns the language from syntax into everyday tooling—shared functions and conventions for data, files, text, and ru
Trust and Verification in Distributed Agents
Distributed agents fail when trust is a slogan instead of a control surface—capabilities, proof, and runtime refusal matter more than model
Latest Trends in Agentic Programming
Agentic programming is moving from demos toward systems that can be operated, audited, and composed—the strongest shifts are about control s