The Glass Runtime: Keeping Humans Close to the Material in an Agentic World

AI is making output abundant. The next constraint is not generation. It is preserving human judgment, understanding, agency, and the ability to intervene as machines do more of the work.

Inspired by Ryo Lu’s “Closer to the Material” at Cursor Compile 2026 — and extended through research on human-computer interaction, automation, software engineering, cognitive debt, agent harnesses, and governed AI systems.

There is a seductive idea at the center of the current agentic AI wave:

If the machine can do more, the human should have to do less.

Less typing. Less coding. Less searching. Less clicking. Less configuration. Less operating.

Eventually, perhaps, you describe an outcome and disappear.

The agent researches, decides, codes, books, deploys, purchases, reconciles, monitors and fixes everything.

From one perspective, this is the logical endpoint of automation.

From another, it may be the wrong objective entirely.

At Cursor’s Compile 2026 conference, Ryo Lu framed the problem through a remarkably simple distinction: black box versus glass.

The black box gives you an output.

Glass lets you remain connected to the material from which that output is being made.

His talk moves through ryOS, collapsing software-development feedback loops, the risks of black-box AI, the distinction between output and material, a proposed “Glass” interface, and ultimately the question of where human craft moves when execution becomes cheap.

That distinction deserves to be taken much further.

Because it is not merely an interface-design question.

It may become one of the fundamental architectural questions of agentic computing:

As agents become more capable, how do we increase machine autonomy without reducing human agency?

The answer, I believe, is that the future needs something stronger than human-in-the-loop.

It needs a Glass Runtime.

Output Is Becoming Cheap. Judgment Is Not.

For most of software history, producing the artifact was expensive.

Writing code was expensive.

Designing interfaces was expensive.

Running experiments was expensive.

Producing documentation was expensive.

Integrating systems was expensive.

That scarcity shaped organizations.

We separated designers from engineers, engineers from operators, analysts from decision-makers, and users from implementation. Ideas moved through documents, mockups, tickets, meetings and handoffs before finally touching the actual material.

AI compresses these loops.

Cursor’s own Design Mode is a good example. Instead of describing an interface change in a ticket, a user can select something in the running product, draw on it or speak about it; the agent receives not merely a sentence but the selected element, surrounding layout, visual context and underlying code. Cursor explicitly describes the goal as shrinking the distance between what the user sees and what the agent understands.

That is more important than it initially appears.

AI does not merely accelerate the old workflow.

It changes where expertise creates value.

When execution is expensive:

idea → specification → implementation → output

When execution approaches zero marginal effort:

intent → generation → judgment → iteration

The bottleneck moves.

Taste becomes more important.

Problem selection becomes more important.

Constraints become more important.

Verification becomes more important.

Knowing what not to build becomes more important.

Knowing when an apparently correct result is subtly wrong becomes much more important.

Ryo’s deeper point is therefore not that craftsmanship disappears.

Craft migrates.

It moves upstream into choosing what deserves to exist.

And downstream into evaluating what deserves to survive.

The Black-Box Paradox

There is, however, an uncomfortable consequence.

The better AI becomes at producing finished output, the easier it becomes for humans to lose contact with how that output came to exist.

Imagine two systems.

System A: The Black Box

Intent
  ↓
Agent
  ↓
Agent
  ↓
Agent
  ↓
Finished result
  ↓
Accept / Reject

The system may be extraordinarily capable.

But the human occupies only two meaningful positions:

1. specify the beginning;
2. judge the end.

Everything important happens in between.

Now consider another architecture.

System B: Glass

Intent
  ↓
Plan ─────────────── inspect / reshape
  ↓
Context ──────────── inspect evidence / provenance
  ↓
Decision ─────────── challenge / constrain
  ↓
Action ───────────── approve / interrupt
  ↓
Result ───────────── modify / undo
  ↓
Learning ─────────── promote / reject

The second system might perform exactly the same amount of computation.

The difference is where the user can touch it.

This is why the conventional phrase human-in-the-loop is increasingly insufficient.

A human can technically be “in the loop” while having almost no meaningful agency.

Clicking Approve on something you cannot reconstruct, inspect or modify is not real control.

It is ceremonial oversight.

We Have Seen This Movie Before

This problem predates generative AI by decades.

In her classic 1983 paper Ironies of Automation, Lisanne Bainbridge observed a paradox: automating routine tasks does not necessarily eliminate the need for humans.

Instead, humans can be left responsible for the exceptional circumstances automation cannot handle — precisely while automation has reduced their opportunities to practise the underlying skill.

The pattern is roughly:

More automation
      ↓
Less direct practice
      ↓
Weaker situational model
      ↓
Human becomes monitor
      ↓
Automation encounters anomaly
      ↓
Human suddenly expected to become expert again

Forty years later, we are reconstructing the same problem around AI agents.

Only at much larger scope.

The developer who once wrote the system becomes the reviewer of generated diffs.

The analyst becomes the reviewer of generated conclusions.

The marketer becomes the reviewer of generated campaigns.

The support operator becomes the approver of generated resolutions.

The traveler becomes the approver of an itinerary assembled through dozens of hidden decisions.

And eventually the enterprise employee may become primarily the supervisor of autonomous work.

The question is therefore not:

Can AI automate this task?

A much better question is:

What cognitive capability does the human lose when we automate this interaction?

And then:

Will they still need that capability when the system eventually fails?

Coding Agents Are Already Showing the Trade-Off

Software engineering gives us an early laboratory for this transition because coding agents are moving unusually quickly.

The evidence is more nuanced than either “AI makes everyone 10× faster” or “AI coding does not work.”

METR’s 2025 randomized controlled trial studied experienced open-source developers performing real tasks in repositories they already knew. With early-2025 AI tools available, developers took 19% longer in that particular experimental setting — despite expecting AI to make them faster. METR subsequently reported newer late-2025 data suggestive of improvement, but with substantial uncertainty around the estimated speedups.

This does not mean coding agents are ineffective.

It tells us something more useful:

output velocity is not the same as engineering productivity.

A 2026 longitudinal study of professional software engineers found that developers reported spending less time writing code and more time performing what the authors call supervisory engineering work — directing, evaluating and correcting AI output. Reported productivity remained high, yet negative developer-experience effects increased among the matched participants, including impacts on flow and cognitive load.

That is an important transition:

Old engineering scarcity:
    producing code
 
Emerging engineering scarcity:
    understanding + evaluating code

The bottleneck has moved from generation to verification.

And there is another, potentially more consequential effect.

From Technical Debt to Cognitive Debt

Technical debt lives in the artifact.

Cognitive debt lives in the people responsible for it.

Margaret-Anne Storey recently proposed a useful three-part model:

• technical debt — problems accumulated in the code;
• cognitive debt — erosion of shared understanding of the system;
• intent debt — missing rationale about why the system exists and why decisions were made.

This distinction becomes critical when AI can produce implementation faster than humans can build mental models of that implementation.

Another 2026 study examining GenAI-assisted software projects identified patterns including black-box acceptance, context mismatch, dependency-induced atrophy and verification bypass — describing the resulting gap as comprehension debt. Interestingly, the same research also found a counter-pattern: when AI was deliberately used as a comprehension scaffold, it could improve understanding rather than weaken it.

That last part matters.

The problem is not AI.

The problem is the interaction contract we build around AI.

The same intelligence can either:

generate → hide → replace understanding

or:

generate → expose → explain → invite modification → increase understanding

This is a product decision.

And increasingly, it is a runtime decision.

The Interface Determines Whether AI Produces Leverage or Atrophy

Human-AI interaction research has spent years pointing in this direction.

The influential 2019 Guidelines for Human-AI Interaction consolidated 18 design guidelines covering expectation setting, correction, explanation, feedback and user control.

Research on mixed-initiative interaction goes back even further: the important unit is not autonomous machine action or direct human control, but the ability for initiative to move intelligently between them.

There is also a useful idea from HCI called seamful design.

Traditional interface design often tries to hide implementation boundaries.

Seamful design asks whether some seams should instead be strategically exposed so users can understand, configure and appropriate a system. Research on seamful explainable AI describes seamfulness as revealing selected complexity or inconsistency when doing so improves user understanding and control.

Agent systems need the same idea.

Not complete transparency.

Not an endless firehose of tokens, logs and traces.

Strategic legibility.

The system should reveal the seam at precisely the moment where understanding the seam changes the decision.

Do Not Confuse Glass With Chain-of-Thought

This distinction is especially important.

A Glass Runtime does not mean dumping a model’s private reasoning into the interface.

That would frequently create noise rather than understanding.

What users need are decision artifacts, not hidden cognition.

For example:

Bad transparency
─────────────────────────────────
Thousands of reasoning tokens
Raw internal scratch work
Every intermediate model hypothesis
 
 
Useful transparency
─────────────────────────────────
What goal is being pursued?
Which constraints are active?
What evidence was used?
Which alternatives were considered?
What decision was made?
Which tool will be called?
What external state will change?
What uncertainty remains?
Can I modify or undo it?

Glass is therefore not about observing the model think.

It is about being able to inspect the contract between reasoning and action.

That is a much more powerful primitive.

Seven Properties of a Glass Runtime

If we take “closer to the material” seriously as an architecture principle rather than a metaphor, several concrete requirements follow.

1. Progressive autonomy

Autonomy should not be binary.

Most systems currently offer something resembling:

manual ←────────────→ autonomous

A better representation is multidimensional.

An agent could have autonomy over:

• information gathering;
• planning;
• recommendation;
• execution;
• spending;
• communication;
• persistent state;
• delegation;
• production deployment.

Each deserves a different authority level.

For example:

Research              AUTO
Recommendation        AUTO
Create draft          AUTO
Modify production     APPROVAL
Spend > ₹10,000       APPROVAL
Delete data           FORBIDDEN

The user should be able to delegate more as confidence grows and reclaim authority when context changes.

This is not merely UX.

It is capability governance.

NIST’s AI risk-management guidance similarly emphasizes explicitly defining human-AI roles, oversight responsibilities and situations requiring human intervention rather than treating oversight as an unspecified fallback.

2. Inspectable intermediate artifacts

Long-running agents should leave behind meaningful objects.

Not simply:

user request
agent response

but:

Intent
Plan
ContextPack
EvidenceRefs
Decision
ToolCall
Approval
Effect
Receipt
Evaluation

These objects create places where humans — and other systems — can intervene.

A plan can be edited.

Evidence can be challenged.

A tool call can be blocked.

An approval can be narrowed.

A completed action can carry a receipt.

A decision can later be replayed.

Once intermediate state becomes typed and durable, the agent stops being a mysterious function.

It becomes an inspectable computational process.

3. Material-native interaction

The best agent interface is often not chat.

If the material is code, show the diff.

If the material is UI, let me point at the interface.

If the material is data, let me manipulate the table.

If the material is travel, expose the itinerary, route, fare conditions and alternatives.

If the material is marketing, show the audience, creative, channel decision and expected trade-offs.

If the material is infrastructure, expose the topology and proposed change.

Cursor’s Design Mode demonstrates this principle directly: spatial UI work is expressed through selections, drawings and the running product itself rather than being compressed entirely into language.

The general rule is:

Use language for intent. Use the material itself for precision.

4. Reversibility

Traditional software optimizes the happy path.

Agentic software must optimize recovery.

Every consequential operation should ask:

Can this action be previewed?
Can it be simulated?
Can it be staged?
Can it be cancelled?
Can it be rolled back?
Can its effects be reconstructed?

As autonomy rises, reversibility becomes increasingly important because the agent can traverse more states before a human notices an error.

The correct architecture is therefore not simply:

Agent → Tool

It is closer to:

Agent
  ↓
Policy
  ↓
Preview / Approval
  ↓
Tool
  ↓
Effect Receipt
  ↓
Rollback / Compensation

That is what turns autonomy into bounded autonomy.

5. Authority must live outside the model

A model may propose an action.

It should not determine whether it is authorized to perform that action.

This separation becomes fundamental in production agents.

The runtime — not the prompt — should decide:

• whose identity the agent is acting under;
• what scopes are available;
• which resources it may access;
• what monetary limits apply;
• what destinations are allowed;
• which actions require approval.

ContextOS already frames this as a separation between model intelligence and deterministic authority: consequential actions flow through governed tool boundaries and produce replayable decision records rather than relying on prompts as security controls.

Glass therefore has two meanings.

Users can see what the system is about to do.

And the architecture places hard glass around what it is allowed to do.

6. Corrections should create learning, not silent mutation

When a user corrects an agent, the system has observed something valuable.

But automatically turning every correction into permanent memory creates another problem.

A production agent should distinguish:

Observation
    ↓
Candidate preference
    ↓
Evidence accumulation
    ↓
Review / confidence
    ↓
Promoted memory or rule

Otherwise agents accumulate accidental preferences, transient instructions and even maliciously injected state.

Human involvement therefore remains important not only during execution but during learning.

The user should be able to understand:

• what the system thinks it learned;
• why;
• where it came from;
• whether it is temporary or durable;
• how to correct or delete it.

That is glass applied to memory.

7. Optimize agency, not just task completion

Most agent benchmarks optimize some version of:

Did the agent finish?

Production systems will need a richer objective.

Consider measuring:

Intervention latency

How quickly can a user detect and alter a wrong trajectory?

Provenance coverage

What percentage of consequential claims can be traced to evidence?

Reversibility coverage

What percentage of external writes have rollback or compensating actions?

Surprise rate

How often does the agent take a consequential action users did not expect?

Correction cost

How difficult is it to redirect the system after a misunderstanding?

Comprehension retention

Does repeated AI use increase or decrease the operator’s understanding of the underlying domain?

Delegation calibration

Do users grant more autonomy only where agent reliability actually justifies it?

These might eventually become Agency SLOs alongside latency, cost, reliability and safety.

Because the real optimization target should not be:

maximum autonomous completion.

It should be:

maximum useful leverage under preserved human agency.

Context Engineering Is Part of Glass

This has another consequence for agent architecture.

The model should not receive an opaque blob of context assembled through invisible retrieval.

Context itself should become inspectable infrastructure.

ContextOS treats this through a distinct Context plane: a runtime compiles policy, tools, evidence, memory, business information and session state into a versioned CompiledContext, with provenance, budgeting and source rules rather than simply concatenating retrieved text into a prompt.

That architecture becomes even more valuable through the Glass lens.

Imagine an agent recommendation showing:

Why this recommendation?
 
Policy
✓ corporate travel policy v7
 
User preferences
✓ prefers nonstop
✓ morning departure
 
Live evidence
✓ fare inventory refreshed 42 sec ago
✓ seat availability refreshed 51 sec ago
 
Memory
✓ inferred aisle preference
  confidence: 0.76
 
Ignored
× old preference from 2024
  reason: superseded

The user does not need 40,000 retrieved tokens.

They need to know which context materially affected the decision.

That is what closeness to the material means for context engineering.

The Five Planes Become Five Glass Surfaces

ContextOS currently describes a production agent runtime through five planes:

Intelligence
     ↓
Context
     ↓
Decision
     ↓
Action
     ↓
Trust

Seen through Ryo’s argument, each plane should expose a different form of useful legibility.

Intelligence

What capabilities exist?

Which model or agent is handling this job?

What are its known limits?

Context

What evidence, memory and policies are shaping the decision?

What is stale or uncertain?

Decision

What conclusion was reached?

What alternatives mattered?

Which constraints dominated?

Action

What external state will change?

Under whose authority?

Can it be stopped or reversed?

Trust

What actually happened?

Did reality match the prediction?

Can the run be replayed?

How did evaluation score it?

Glass is therefore not another plane.

Glass is a property that cuts through every plane.

The Agent Harness Becomes the New Interface Layer

There is a second architectural implication.

As models become more interchangeable, much of the product experience moves into the agent harness.

Cursor itself describes extensive harness engineering around prompts, tools, context handling, agent dispatch and coordination, noting that the same underlying model can behave very differently depending on its surrounding harness.

That means future competition will not simply be:

Model A vs Model B

It will increasingly become:

Model
×
Context compiler
×
Memory system
×
Tool surface
×
Authority model
×
Evaluation
×
Interaction design
×
Recovery

The harness is where intelligence becomes a system.

And therefore the harness is also where human agency can either be preserved or accidentally designed away.

The Ultimate Agent Is Not Invisible

For years, software design has treated invisibility as an ideal.

The best interface disappears.

The best automation happens without asking.

The best infrastructure is never noticed.

That remains useful for many operations.

Nobody wants to manually manage TCP packets while booking a hotel.

But agentic systems create a different class of abstraction.

They increasingly make judgments on our behalf.

And judgments are not implementation details.

A travel agent deciding that a cheaper 5 a.m. flight is “better” than the 9 a.m. flight is making a value judgment.

A coding agent choosing architectural convenience over maintainability is making a value judgment.

A marketing agent deciding whom not to target is making a value judgment.

An enterprise agent deciding that a support case qualifies for a refund is making a value judgment.

The more AI participates in decisions, the less appropriate total invisibility becomes.

The correct goal is not visibility everywhere.

It is:

progressive disclosure with sufficient depth to recover agency whenever it matters.

Simple on the surface.

Inspectability underneath.

And meaningful control all the way down.

That is Glass.

A Different Definition of AI-Native

We often describe an AI-native product as one in which AI can perform more of the workflow.

That definition is incomplete.

A genuinely AI-native system should allow both sides of the relationship to become more capable.

The machine should become better at executing.

The human should become better at directing, judging and understanding.

                 BLACK BOX
 
Human capability ───────────────→ may decline
Machine capability ───────────────────────→ rises
 
 
                   GLASS
 
Human capability ────────────────────────→ rises
Machine capability ──────────────────────→ rises
                         ↑
                    collaboration

The most powerful technology should not require progressively less capable humans around it.

It should increase the radius of what a capable human can understand and shape.

Craft Did Not Die. It Moved.

AI will generate more code than humans.

More images.

More interfaces.

More analysis.

More decisions.

More software.

More everything.

That does not make human judgment irrelevant.

It makes judgment scarce.

When production becomes abundant, choosing becomes valuable.

When implementation becomes cheap, intent becomes valuable.

When outputs become infinite, refusal becomes valuable.

When systems move faster than humans can inspect them, provenance becomes valuable.

When agents can act autonomously, reversibility becomes valuable.

And when a machine can produce something superficially excellent in seconds, knowing whether that thing deserves to exist becomes perhaps the most human capability of all.

Ryo Lu’s phrase “closer to the material” is therefore much larger than a design philosophy for coding tools.

It is a warning about the architecture of automation itself.

We should absolutely build agents that can do extraordinary amounts of work for us.

But capability alone is an incomplete objective.

The real design challenge is to build systems where increasing machine intelligence does not require surrendering human agency.

Systems where you can delegate without disappearing.

Automate without becoming ignorant.

Move faster without losing understanding.

Use abstraction without losing touch with reality.

And ask an increasingly powerful machine not merely:

Can you build this?

but still retain enough judgment to ask:

Should this exist?

That is the difference between an agent that produces output and a system that extends human capability.

The future should not be a better black box.

It should be glass.

What to read next

• Beyond Prompts: The Architecture of Trust
• Human Oversight for Agent Fleets: Confidence Is Not an Audit Policy
• Reversibility Is the Missing Safety Primitive for AI Agents
• The Agent Harness Whitepaper