Field index
Ideas
Shorter than the essays. A claim, the reason I hold it, and where it might be wrong.
These months indicate approximately when an idea first appeared in my notes, work, or public writing, not necessarily when it first appeared on this site.
Browse by thread
September 2026
9 ideas
An agent can own the mistake. It cannot own the cost.
Accountability means bearing the downside. An agent that spends money it cannot repay needs a limit set before it acts, not an apology after.
Autonomy should scale with reversibility
The useful question is not whether an AI agent is autonomous, but how much autonomy makes sense for a particular action.
Clarification is part of intelligence
A system that confidently completes the wrong task is not more intelligent than one that knows when it needs to ask.
Novelty belongs to models. Repetition belongs to software.
Use a generative model to find a path the first time. Once the path repeats, call it. Do not pay a model to rediscover it.
Policy should not be probabilistic
A classifier may return a probability. The rule that permits an action should still be code you can read, version, and test.
The best agent workflow eventually stops looking agentic
An agent loop is a reasonable way to discover a procedure. It is a poor way to run one you already trust.
Buy the decision, not the dashboard
The software worth trusting in a business shortens the path from a fact to a commitment someone will sign.
Routing is a product decision
Choosing a path is not only a cost and latency problem. The policy says what good enough means, and whether the user can see the switch.
An agent needs a job, not a persona
A role and a manner of speaking make a demo. A job has inputs, a definition of done, and a person who owns the outcome.
August 2026
2 ideas
Leasing can be part of product design
For infrastructure products, a lease can define control, maintenance, service expectations, and what happens when equipment ages.
The first useful answer may be a validation plan
Early ideas often need a cheap test of their assumptions more than they need a polished recommendation.
July 2026
2 ideas
Treat AI adoption as a portfolio, not a project
Any single AI initiative may fail. The portfolio has to pay. Each one needs a cost, an expected return, an owner, and a moment when someone decides to scale it or stop it.
Infrastructure software can quietly become a financing business
When software depends on hardware, replacement, insurance, and lifecycle management, the balance sheet becomes part of the product.
June 2026
3 ideas
Whoever assembles the tools owns the boundary
A model developer can say what a model was trained to do. Only the party that connected the tools and set the permissions can say what the system is allowed to do.
Open source the layer people need to trust
The boundary between open and proprietary should follow where independent inspection matters, not a general philosophy about software.
Tokens may be the wrong unit for compute value
Token count is easy to meter, but it does not represent the same work, service quality, or value across systems and tasks.
May 2026
2 ideas
A goal is more useful than a persona
A persona shapes how an assistant speaks; a goal tells the system what future state it is trying to help create.
More review is not always more safety
Safety should come from clear gates around consequential changes, not from making every small change wait for everything else.
April 2026
3 ideas
You can only govern what you can diff
A rule that lives in a prompt or a context window changes without anyone deciding it should. Governance needs behavior that can be versioned and compared.
A model should know which mode the user is in
The same request needs different behavior when a person is exploring, deciding, building, or authorizing action.
The system should remember decisions, not every conversation
Durable state is the record of what was chosen, why, and what evidence would cause the choice to change.
March 2026
5 ideas
Coding agents can optimize the wrong stage
An agent can produce excellent implementation work while the product is still asking a more important, earlier question.
Declarative intelligence may be the missing layer
Many agent decisions need a constrained label, score, or probability, not another open-ended paragraph.
Good systems expose their assumptions before their confidence
A conclusion becomes more useful when the assumptions supporting it, and the evidence that could break it, are visible.
Software should mature through four stages
AI-assisted products move from novelty to usefulness, dependability, and refinement, and each stage needs different work.
Tool selection is part of the decision, not an afterthought
Choosing a tool also chooses a permission boundary, an execution path, and a particular risk surface.
February 2026
7 ideas
AI will make analysis abundant before it makes judgment abundant
Generating more comparisons and recommendations does not create ownership of the decision or the judgment to make it well.
An answer's provenance should include where it ran
Model identity is only part of provenance when execution location changes privacy, latency, cost, and trust.
Local AI is a scheduling problem before it is a model problem
The practical limit of local AI is often useful throughput, routing, and graceful fallback rather than headline model size.
Parallel agents need a dependency graph, not a group chat
More agents do not automatically make work faster; parallelism becomes useful only when dependencies are explicit.
Resource sharing moves the capital problem; it does not eliminate it
Spare compute may look capital-light to a network, but the assets, depreciation, energy, and maintenance still belong to someone.
The most important context is the trajectory
A personal system needs more than facts about the present; it needs to understand the direction the person is trying to move.
Token efficiency is an architectural concern
Repeatedly rediscovering context and decisions is not merely expensive; it is evidence that the system has forgotten its own structure.
January 2026
3 ideas
An agent should have its own identity
An agent that acts under a person's borrowed credentials cannot be scoped, revoked, or traced apart from that person. Delegation needs a principal of its own.
A model can recommend authority; it should not grant it
Model judgment can inform a policy, but authority should come from something explicit enough to review and test.
An audit log is not a control
A record written after an action is evidence; it cannot substitute for a rule capable of stopping the action beforehand.
December 2025
2 ideas
Permissions should expire with the work
Agent authority should be narrow, short-lived, and tied to a particular identity, action, resource, and time window.
The place that performs the action should be able to say no
Policy becomes real only when the system that sends, deletes, spends, or changes a record can refuse the action.
November 2025
2 ideas
A personal AI appliance should feel boring
Personal AI becomes successful infrastructure when availability, privacy, resource use, and recovery stop demanding attention.
Consumer hardware becomes infrastructure only when the complexity disappears
Powerful machines become dependable infrastructure only after variation in hardware, runtimes, networks, and failure modes is absorbed.
October 2025
2 ideas
The customer should not need the architecture lesson
Architecture earns its place when customers can feel the privacy, speed, resilience, control, or lower cost it creates.
The frontend is the door, not the system
The interface may change, but the user's context, authority, tools, and work should remain coherent behind it.
September 2025
2 ideas
Failure should reduce capability, not destroy the system
A resilient AI system should fall back to a smaller, safer set of capabilities when one component becomes unavailable.
The best escalation path is a product feature
What happens when an AI system is uncertain often matters more than another improvement to its average-case benchmark.
No ideas match that search yet.