I-7 Cognitive Loop: A new standard for Human-AI interaction

Key takeaways

• I-7 does not replace Norman; it extends Norman for non-deterministic systems.
• The shift is from direct manipulation to delegated execution.
• In AI-assisted work, visibility and intervention are design requirements.
• The seven stages make human oversight operational, not optional.

Norman remains the foundation. The seven stages of action still describe how people form goals, act, and evaluate outcomes. The difference is that modern AI systems can reason, choose tools, and execute intermediate steps on their own. I-7 is an advanced layer for this environment: the age of AI-assisted development, where human judgment stays central.

In practice, clarity at boundaries reduces downstream errors more than late-stage tuning.

Act I: The shift

Why Norman needs an extension

Norman’s model was shaped around tools where execution was explicit and deterministic. You click, the system does the exact action, and you compare the result.

Agentic systems change that middle layer. Between intent and output, there is now hidden reasoning, retrieval, tool calls, and probabilistic generation. That creates a practical gap: users can still state goals, but they cannot safely trust execution unless reasoning and control points are visible.

The I-7 loop addresses that gap by inserting operational checkpoints before, during, and after execution.

Norman’s Stage	I-7 Cognitive Stage	Nature of the Shift	Key Cognitive Demand
Goal Formation	Intent	Vague internal states become structured intent.	Role-task alignment and explicit boundaries.
Intent/Specification	Inform	Focus moves from “how to click” to “what context is required.”	Context engineering and attention management.
Execution	Initiate	The system begins action through autonomous reasoning.	Reasoning-action control and safe execution contracts.
Perception	Interpret	Human and agent build a shared model before execution scales.	Semantic alignment and assumption testing.
Interpretation	Inspect	Post-hoc reading becomes evidence-based runtime inspection.	Observability of reasoning traces and outputs.
Evaluation	Intervene	Evaluation becomes active pause/correct authority.	Human-in-the-loop governance and autonomy scaling.
Not in Norman	Iterate	Each run is folded into a learning loop for better future runs.	Golden examples, policy updates, and PDCA discipline.

The I-7 loop

I-7 runs as a repeatable control cycle:

• Intent -> Inform -> Interpret -> Initiate -> Inspect -> Intervene -> Iterate

The value is not the labels alone. The value is that each label marks a decision point where responsibility is explicit.

Act II: The seven phases

Intent

Intent is the contract. It defines role, task, boundaries, and failure conditions.

If skipped: the system optimizes for fluency over correctness.

Examples:

• Developer: “Refactor this module without changing the public API.”
• Product manager: “Draft a v1 PRD for onboarding with scope limits and non-goals.”
• Researcher: “Summarize only claims directly supported by cited sources.”

Inform

Inform is context governance. You choose what evidence the system may use.

If skipped: low-signal context causes plausible but ungrounded outputs.

Examples:

• Developer: provide failing tests, target files, and logs.
• Product manager: provide interview notes, key metrics, and constraints.
• Researcher: provide canonical papers and explicit exclusions.

Interpret

Interpret is pre-execution alignment. The system states plan and assumptions in plain language.

If skipped: users discover misalignment only after execution side effects.

Examples:

• Developer: ask for a step plan before file edits.
• Product manager: ask for trade-off framing before writing.
• Researcher: ask for hypothesis and evidence chain before synthesis.

Initiate

Initiate is guarded execution. Actions should pass schema and policy checks.

If skipped: malformed tool calls and unsafe actions move into runtime.

Examples:

• Developer: patch only after diff preview and lint/test gate.
• Product manager: ticket creation only after required fields validate.
• Researcher: data queries only after schema and source checks pass.

Inspect

Inspect is output verification against evidence and acceptance criteria.

If skipped: hallucinations and logic drift become part of the baseline.

Examples:

• Developer: verify tests, type checks, and behavior diffs.
• Product manager: verify PRD traceability to source interviews.
• Researcher: verify every claim maps to a source fragment.

Intervene

Intervene is explicit human authority to pause, redirect, or reject.

If skipped: autonomy scales faster than accountability.

Examples:

• Developer: block migration without rollback proof.
• Product manager: stop launch when success metrics are ambiguous.
• Researcher: halt conclusions where evidence conflicts remain unresolved.

Iterate

Iterate turns corrections into reusable system memory: tests, prompts, policies, and examples.

If skipped: the same errors recur in new language.

Examples:

• Developer: convert incident fixes into regression tests.
• Product manager: convert review feedback into template constraints.
• Researcher: convert corrected citations into a retrieval benchmark set.

Act III: Using the loop

AI-assisted, not AI-generated

I-7 is designed for AI-assisted development. The system contributes speed and synthesis; the human owns intent, judgment, and accountability.

A practical run loop

Use this five-minute loop in any agent workflow:

1. Write Intent in one sentence (role, task, boundary).
2. Attach only required context for the task.
3. Ask for plan and assumptions before execution.
4. Run with explicit guardrails and inspect outputs.
5. Save one correction as a reusable artifact.

Related systems

For adjacent concepts:

• Systems 001: Foundations
• Retrieval-Augmented Generation in plain terms
• Training vs inference
• Context windows as working memory

Related resources

• The I-7 Reliability Standard deck

What this changes in practice

You stop treating interaction as prompt-in, answer-out. You start treating it as a governed loop with observable state transitions. That shift is the difference between impressive demos and reliable systems.

Proof Block

• Extends Norman cognitive loop for AI systems
• Defines 7 stages of human-AI interaction

FAQ

What is the I-7 cognitive loop?

The I-7 cognitive loop extends Norman's classic human-computer interaction model to AI-assisted work. It adds stages for delegation, context transfer, and intervention that account for non-deterministic AI behavior that does not fit traditional direct manipulation models.

How does I-7 differ from Norman's model?

Norman's model assumes deterministic execution: you act, the system responds predictably. I-7 adds stages for when the AI proposes, when context must transfer between human and AI, and when humans need visibility into and control over AI decisions. The shift is from direct manipulation to delegated execution.

Why is visibility a design requirement in AI systems?

Unlike traditional software where you can trace exactly what code ran, AI systems make probabilistic decisions that are not easily explainable. Visibility requirements ensure humans can understand what the AI is doing, intervene when needed, and maintain accountability for outcomes.