Intent: Operating System for AI-Augmented Teams

The Problem

Knowledge work is still largely invisible. Teams use AI for individual tasks—writing, coding, analysis—but they haven't reorganized around it. They're bolting AI tools onto existing workflows instead of reimagining the workflows themselves.

The result: AI feels useful but inconsistent. Some projects benefit massively. Others waste time. Teams can't learn from what worked because nothing is observable.

The Insight

Teams that win with AI do something different. They structure work around specs—explicit descriptions of what they want built. They hand specs to AI agents and observe the results. They iterate on specs, not on processes.

This isn't new in software. It's been the standard for decades: spec → build → test → ship. What's new is adding observe and notice, and doing it in a tight, continuous loop with AI agents handling the execution.

The Solution: Intent

Intent is a personal operating system built on the notice→spec→execute→observe loop:

• Notice: Spot a problem, pain, or opportunity in your work. Make the observation concrete.
• Spec: Write down exactly what you want built, with constraints, success criteria, and delivery timeline. This is intent made explicit.
• Execute: Hand the spec to an AI agent (Claude, a tool, a bot). It builds reliably. You observe the output.
• Observe: Watch what happened. Did it work? What broke? Observations feed back into notice.

This loop is powerful because:

• Specs are unambiguous. AI executes them reliably.
• Every execution is observable and traceable.
• Feedback loops are tight—hours or days, not quarters.
• Teams learn what works. Winning patterns become standard.

Why This Matters Now

AI models have reached a point where they can execute complex specs reliably. Claude can write code from a detailed spec. It can analyze documents, build workflows, design systems. The limiting factor isn't AI capability—it's the clarity of intent on the human side.

Intent addresses that. It gives teams a framework for clarifying intent, structuring work around that intent, and building feedback loops to improve continuously.

The teams that adopt this first will have a massive advantage. They'll be faster, more innovative, and more adaptable than teams still building by committee or trial-and-error.

What Intent Includes

Intent as a system includes:

• Signals: Structured observability data that makes work visible. Every decision, every execution leaves signals.
• Decisions: A framework for recording decisions and their outcomes. This builds institutional memory.
• Templates: Spec templates, decision templates, observation templates. Consistency at scale.
• Tools: Integration with git, AI APIs, monitoring systems. Automation of the loop itself.

Trust-Scored Autonomy

A core innovation in Intent is how we determine how much autonomy an AI agent gets. Instead of binary allow/deny decisions, we use a mathematical trust formula that scores the clarity and safety of any given task.

The Trust Formula:

trust = clarity×0.30 + (1/blast_radius)×0.20 + reversibility×0.20 + testability×0.20 + precedent×0.10

Each factor is scored 0-1:

• Clarity (30%): How unambiguous is the spec? Are edge cases covered?
• 1/Blast Radius (20%): How limited are the consequences if the agent gets it wrong? Small blast radius (say, a draft document) scores high. Large blast radius (production data deletion) scores low.
• Reversibility (20%): Can we undo this? Git commits are highly reversible (1.0). Sent emails are not (0.0).
• Testability (20%): Can we verify the work before it goes live? Code review, staged deployments, and test runs all score high.
• Precedent (10%): Have we done something similar before and had good outcomes?

Autonomy Levels: The trust score maps to five autonomy levels:

• L0 (<0.2): Human drives. Agent assists, suggests, answers questions. No autonomous execution.
• L1 (0.2-0.4): Agent suggests. Human must review and approve before execution.
• L2 (0.4-0.6): Agent proposes. Human can veto, but execution happens by default if no veto is given within a time window.
• L3 (0.6-0.85): Agent executes with monitoring. Autonomous execution with observability dashboards and circuit breakers. Human can interrupt.
• L4 (≥0.85): Full autonomy. Agent executes, logs results, and continues unless an exception condition triggers a circuit breaker.

The Key Insight: Math replaces politics. There's no ambiguity about "how much autonomy is too much?" The trust score makes it explicit and auditable.

Dogfooding

Intent is being built using the Intent methodology. This isn't theoretical—it's live and measurable.

• 16 real signals captured from development sessions, tracking notices, specs written, execution outcomes, and blockers.
• 14 specification documents driving the product roadmap, architecture, and feature development.
• Live event stream tracking all system activity: commits, deployments, decisions made, and outcomes observed.

This means we're continuously improving the methodology based on real data from building Intent itself. See the Dogfood Dashboard for the full picture of how Intent is eating its own dog food.

Specifications & Artifacts

Intent is documented and built in public. These artifacts form the blueprint:

The Vision

In the near term, Intent is a personal operating system for individual knowledge workers augmented by AI. You use it to structure your own work, improve your own processes, and build systems that others can adopt.

In the longer term, Intent is an operating system for teams. Every team member has clarity on the loop. Specs flow from notice to execution to observation. Signals feed back into decision-making. The team learns continuously.

And eventually, Intent becomes a business operating system. Companies that run on Intent-based principles—explicit intent, observable execution, tight feedback loops—will outcompete companies still running on old waterfall or agile ceremonies.