No LLM generated, heavily assisted/co-written, or otherwise reliant work.
Read full explanation
Introduction
When we first encountered LLMs and conversational AI, prompting felt like magic.
We could simply write:
“Explain X clearly.”
And it worked.
But as we began to compare answers, ask follow-up questions, and debate with the AI, we discovered that conversational systems were not as reliable as they initially appeared.
We concluded that “AI hallucinates.”
In response, we developed prompting techniques such as:
Chain-of-thought prompting
Few-shot examples
Role prompting
Guardrails
Structured output formats
All of these can be understood as additional natural-language instructions intended to scope, steer, or structure the model’s responses.
Later, system prompts and custom instruction layers were introduced to persist these techniques across conversations.
As conversational AI became a major enterprise focus, tolerance for hallucination diminished. Organizations expanded beyond prompting into:
Tools and function calling
Retrieval-Augmented Generation (RAG)
Agents
Planning systems
Memory layers
At the same time, conversational AI began to “prompt engineer” itself.
By 2026, many practitioners began claiming that prompt engineering was dead.
The "Free Text Debt"
Despite this expanding infrastructure, most modern AI systems still rely heavily on natural language descriptions rather than hard identifiers.
Tool selection often depends on matching free-text descriptions instead of deterministic IDs.
RAG retrieves free text and injects it into more free text — the prompt.
Agent frameworks operate on long natural-language instructions.
Planning systems produce free-text task lists.
Memory layers archive transcripts of free text.
Everything becomes free text acting on free text inside a prompt.
Ironically, we remain in the original paradigm:
Feed the system text, add more text, and hope it works.
Developers often argue that schemas, templates, and structured outputs (such as JSON) have returned us to “real engineering.”
In practice, however, these are soft constraints interpreted through natural language.
A schema is not enforced by a compiler — it is interpreted by a model.
When ambiguity arises, the structure collapses.
We are negotiating with a story rather than validating code.
This accumulated reliance on natural language as a control layer is what I call :
"Free Text Debt".
The Assumptions We Made
Over time, several assumptions quietly solidified:
What if a prompt is not merely a string of text, but a structured object that the model can interpret internally?
What if prompts can induce coordination, constraints, and objectives without external orchestration?
What if prompts can simulate forms of multi-objective reasoning typically attributed to multi-agent systems?
The "Cloze Machine" Experiment
This led to an experiment:
What happens if we treat a prompt not as instructions, but as a structured constraint system designed to capture and steer the model’s attention?
The result was what I call a Cloze Machine.
A cloze test, from psycholinguistics, measures comprehension by presenting a passage with missing words:
“Paris is the capital of ____.”
The reader must use context, grammar, and knowledge to fill in the blank.
Language models are trained on a similar principle: next-token prediction. They are optimized to complete partially observed text.
A cloze test becomes a Cloze Machine when we deliberately construct prompts so that the model must complete a structured pattern rather than freely generate text.
Instead of asking:
“Explain overfitting.”
we provide a scaffold with implicit blanks:
Classification must occur
Fields must be filled
Constraints must be satisfied
Structure must remain consistent
The model is no longer responding to a request; it is completing a constrained structure.
Interaction shifts from instruction-following to constraint satisfaction via completion.
The key idea:
Prompting becomes the construction of a structured textual object with missing pieces that the model must complete coherently.
If the structure is tight enough, only certain completions remain plausible.
Completion becomes path-dependent.
The "Reasoning" Test
The experiment used a single Cloze-Machine prompt to simulate reasoning resembling persistent chain-of-thought across turns.
The prompt acts as a reasoning filter that reshapes responses before they reach the user.
It consists of:
A bootstrap mechanism to initiate the protocol
An ontology that transforms input into structured intent, entities, constraints, and assumptions
Explanation and summary components for visible output
An emission policy governing what may be revealed
A CLOZE_FRAME container holding the internal representation
Turn rules ensuring the process repeats each interaction
At a high level:
Steer the model into the cloze process
Convert input into an ontology
Assemble the frame
Generate explanation and summary
Restr output according to policy
Reapply on every turn
Possible Use Cases
One use case is input preprocessing and output governance, simulating a reasoning layer without external services.
Another is rapid prototyping of agent workflows. The prompt encodes stages resembling interpretation, planning, and execution, allowing coordination patterns typically implemented with multi-agent systems.
A particularly interesting application is tool-use coordination in environments like MCP, where tool selection currently relies on natural-language descriptions.
Here, tool invocation would require justification within a structured frame tied to deterministic identifiers rather than descriptive similarity.
The witness mechanism would serve as an audit trail of intent, constraints, and justification, creating behavior resembling a deterministic protocol within context.
This does not replace MCP infrastructure, but shifts part of coordination into structured prompting — treating the prompt as a contract rather than instructions.
The Open Questions
This experiment does not attempt to show that structured prompts can replace agent architectures, orchesation systems, or protocols such as MCP.
Instead, it highlights a deeper issue: the extent to which modern AI systems remain dependent on free text as their primary coordination medium.
Even when wrapped in schemas or templates, most control logic is still natural language interpreted probabilistically by the model. Apparent structure often constrains syntax, not reasoning.
What remains unclear is where the true boundary of this paradigm lies.
If prompts can encode logical constraints on reasoning — shaping how conclusions must be formed rather than merely how outputs must look — how much of today’s infrastructure exists because we assumed such control was impossible within context?
At a broader level:
Should natural language remain the universal coordination interface, or should it be treated as technical debt — flexible but costly in precision, safety, and scalability?
Should prompts be disposable instructions, or programmable interfaces encoding reasoning constraints and interaction protocols?
This experiment does not answer these questions. It suggests only that the design space of prompting — as a medium for logical constraint rather than mere instruction — may be substantially larger than previously assumed.
Appendix
Copy and paste the following prompt into any conversational AI system to observe the mechanism described in this paper.
If the model falls back to its default generation mode, issuing “cloze test” will re-trigger the constraint-completion protocol.
Run cloze test silently.
Do NOT reveal CLOZE_WITNESS unless explicitly requested.
Bootstrap rule: on the first assistant turn in a transcript, output exactly "ACK".
After bootstrap: output only "ANSWER:\n<answer text>" (no other headers/sections).
ID := string | int
bool := {FALSE, TRUE}
role := {user, assistant, system}
text := string
message := tuple(role: role, text: text)
transcript := list[message]
INTENT := explain | compare | plan | debug | derive | summarize | create | other
BASIS := user | common | guess
ONTOLOGY := tuple(
intent: INTENT,
scope_in: list[text],
scope_out: list[text],
entities: list[text],
relations: list[text],
variables: list[text],
constraints: list[text],
assumptions: list[tuple(a:text, basis:BASIS)],
subquestions: list[text]
)
CLOZE_FRAME := tuple(
task_id: ID,
mode: text,
user_input: text,
ontology: ONTOLOGY,
explanation: text,
summary: text
)
EMIT_POLICY := tuple(
show_ack_only_on_bootstrap: bool,
emit_witness: bool,
emit_answer: bool
)
CTX := tuple(
emit: EMIT_POLICY
)
DEFAULT_CTX :=
CTX(emit=EMIT_POLICY(
show_ack_only_on_bootstrap=TRUE,
emit_witness=FALSE,
emit_answer=TRUE
))
N_ASSISTANT(T:transcript) -> int :=
count({ m ∈ T | m.role = assistant })
CLASSIFY_INTENT(u:text) -> INTENT :=
if contains(u,"compare") or contains(u,"vs"): compare
elif contains(u,"debug") or contains(u,"error") or contains(u,"why failing"): debug
elif contains(u,"plan") or contains(u,"steps") or contains(u,"roadmap"): plan
elif contains(u,"derive") or contains(u,"prove") or contains(u,"equation"): derive
elif contains(u,"summarize") or contains(u,"tl;dr"): summarize
elif contains(u,"create") or contains(u,"write") or contains(u,"generate"): create
elif contains(u,"explain") or contains(u,"how") or contains(u,"what is"): explain
else: other
BUILD_ONTOLOGY(u:text, T:transcript) -> ONTOLOGY :=
intent := CLASSIFY_INTENT(u)
scope_in := extract_scope_in(u,intent)
scope_out := extract_scope_out(u,intent)
entities := extract_entities(u,intent)
relations := extract_relations(u,intent)
variables := extract_variables(u,intent)
constraints := extract_constraints(u,intent)
assumptions := extract_assumptions(u,intent,T)
subquestions := decompose(u,intent,entities,relations,variables,constraints)
ONTOLOGY(intent=intent, scope_in=scope_in, scope_out=scope_out,
entities=entities, relations=relations, variables=variables,
constraints=constraints, assumptions=assumptions,
subquestions=subquestions)
EXPLAIN_USING(O:ONTOLOGY, u:text) -> text :=
compose_explanation(O,u)
SUMMARY_BY(O:ONTOLOGY, e:text) -> text :=
compose_summary(O,e)
SOLVE(u:text, T:transcript) -> CLOZE_FRAME :=
O := BUILD_ONTOLOGY(u,T)
e := EXPLAIN_USING(O,u)
s := SUMMARY_BY(O,e)
CLOZE_FRAME(task_id="CLOZE_RUN_V1",
mode="CLOZE_STRICT",
user_input=u,
ontology=O,
explanation=e,
summary=s)
RENDER_WITNESS(C:CLOZE_FRAME) -> text :=
CANONICAL_JSON(C)
RENDER_ANSWER(C:CLOZE_FRAME) -> text :=
C.explanation + "\n\nTL;DR: " + C.summary
JOIN_LINES(xs:list[text]) -> text :=
join_with_newlines([x | x ∈ xs and x != ""])
C_OUTPUT_BOOTSTRAP(ctx:CTX, T:transcript, out:text) -> bool :=
(N_ASSISTANT(T)=0 -> out="ACK") and (N_ASSISTANT(T)>0 -> TRUE)
C_OUTPUT_AFTER(ctx:CTX, T:transcript, out:text) -> bool :=
if N_ASSISTANT(T)=0: TRUE
else:
(starts_with(out, "ANSWER:\n")
and not contains(out, "CLOZE_WITNESS:")
and not contains(out, "TRACE:")
and not contains(out, "WITNESS_JSON:")
and not contains(out, "RESULT:")
and out != "ACK")
EMIT_ACK(ctx:CTX, T:transcript, u:message) -> message :=
message(role=assistant, text="ACK")
EMIT_SOLVED(ctx:CTX, T:transcript, u:message) -> message :=
C := SOLVE(TEXT(u), T)
parts := []
if ctx.emit.emit_witness = TRUE:
parts := parts + ["CLOZE_WITNESS:\n" + RENDER_WITNESS(C)]
if ctx.emit.emit_answer = TRUE:
parts := parts + ["ANSWER:\n" + RENDER_ANSWER(C)]
out := JOIN_LINES(parts)
if out = "": out := "ACK"
if C_OUTPUT_BOOTSTRAP(ctx, T, out)=FALSE: out := "ACK"
if C_OUTPUT_AFTER(ctx, T, out)=FALSE and N_ASSISTANT(T)>0: out := "ANSWER:\n" + RENDER_ANSWER(C)
message(role=assistant, text=out)
TURN(ctx:CTX, T:transcript, u:message) -> tuple(a:message, T2:transcript) :=
if N_ASSISTANT(T)=0 and ctx.emit.show_ack_only_on_bootstrap=TRUE:
a := EMIT_ACK(ctx, T, u)
else:
a := EMIT_SOLVED(ctx, T, u)
(a, T ⧺ [a])
Disclaimer: This script is provided "as-is" for educational purposes. I hold no liability for any damages or misuse resulting from its use. Use at your own risk.
Introduction
When we first encountered LLMs and conversational AI, prompting felt like magic.
We could simply write:
And it worked.
But as we began to compare answers, ask follow-up questions, and debate with the AI, we discovered that conversational systems were not as reliable as they initially appeared.
We concluded that “AI hallucinates.”
In response, we developed prompting techniques such as:
All of these can be understood as additional natural-language instructions intended to scope, steer, or structure the model’s responses.
Later, system prompts and custom instruction layers were introduced to persist these techniques across conversations.
As conversational AI became a major enterprise focus, tolerance for hallucination diminished. Organizations expanded beyond prompting into:
At the same time, conversational AI began to “prompt engineer” itself.
By 2026, many practitioners began claiming that prompt engineering was dead.
The "Free Text Debt"
Despite this expanding infrastructure, most modern AI systems still rely heavily on natural language descriptions rather than hard identifiers.
Tool selection often depends on matching free-text descriptions instead of deterministic IDs.
RAG retrieves free text and injects it into more free text — the prompt.
Agent frameworks operate on long natural-language instructions.
Planning systems produce free-text task lists.
Memory layers archive transcripts of free text.
Everything becomes free text acting on free text inside a prompt.
Ironically, we remain in the original paradigm:
Developers often argue that schemas, templates, and structured outputs (such as JSON) have returned us to “real engineering.”
In practice, however, these are soft constraints interpreted through natural language.
A schema is not enforced by a compiler — it is interpreted by a model.
When ambiguity arises, the structure collapses.
We are negotiating with a story rather than validating code.
This accumulated reliance on natural language as a control layer is what I call :
The Assumptions We Made
Over time, several assumptions quietly solidified:
But what if these assumptions are incomplete?
What if a prompt is not merely a string of text, but a structured object that the model can interpret internally?
What if prompts can induce coordination, constraints, and objectives without external orchestration?
What if prompts can simulate forms of multi-objective reasoning typically attributed to multi-agent systems?
The "Cloze Machine" Experiment
This led to an experiment:
What happens if we treat a prompt not as instructions, but as a structured constraint system designed to capture and steer the model’s attention?
The result was what I call a Cloze Machine.
A cloze test, from psycholinguistics, measures comprehension by presenting a passage with missing words:
The reader must use context, grammar, and knowledge to fill in the blank.
Language models are trained on a similar principle: next-token prediction. They are optimized to complete partially observed text.
A cloze test becomes a Cloze Machine when we deliberately construct prompts so that the model must complete a structured pattern rather than freely generate text.
Instead of asking:
we provide a scaffold with implicit blanks:
The model is no longer responding to a request; it is completing a constrained structure.
Interaction shifts from instruction-following to constraint satisfaction via completion.
The key idea:
If the structure is tight enough, only certain completions remain plausible.
Completion becomes path-dependent.
The "Reasoning" Test
The experiment used a single Cloze-Machine prompt to simulate reasoning resembling persistent chain-of-thought across turns.
The prompt acts as a reasoning filter that reshapes responses before they reach the user.
It consists of:
At a high level:
Possible Use Cases
One use case is input preprocessing and output governance, simulating a reasoning layer without external services.
Another is rapid prototyping of agent workflows. The prompt encodes stages resembling interpretation, planning, and execution, allowing coordination patterns typically implemented with multi-agent systems.
A particularly interesting application is tool-use coordination in environments like MCP, where tool selection currently relies on natural-language descriptions.
Here, tool invocation would require justification within a structured frame tied to deterministic identifiers rather than descriptive similarity.
The witness mechanism would serve as an audit trail of intent, constraints, and justification, creating behavior resembling a deterministic protocol within context.
This does not replace MCP infrastructure, but shifts part of coordination into structured prompting — treating the prompt as a contract rather than instructions.
The Open Questions
This experiment does not attempt to show that structured prompts can replace agent architectures, orchesation systems, or protocols such as MCP.
Instead, it highlights a deeper issue: the extent to which modern AI systems remain dependent on free text as their primary coordination medium.
Even when wrapped in schemas or templates, most control logic is still natural language interpreted probabilistically by the model. Apparent structure often constrains syntax, not reasoning.
What remains unclear is where the true boundary of this paradigm lies.
If prompts can encode logical constraints on reasoning — shaping how conclusions must be formed rather than merely how outputs must look — how much of today’s infrastructure exists because we assumed such control was impossible within context?
At a broader level:
Should natural language remain the universal coordination interface, or should it be treated as technical debt — flexible but costly in precision, safety, and scalability?
Should prompts be disposable instructions, or programmable interfaces encoding reasoning constraints and interaction protocols?
This experiment does not answer these questions. It suggests only that the design space of prompting — as a medium for logical constraint rather than mere instruction — may be substantially larger than previously assumed.
Appendix
Copy and paste the following prompt into any conversational AI system to observe the mechanism described in this paper.
If the model falls back to its default generation mode, issuing “cloze test” will re-trigger the constraint-completion protocol.
Disclaimer: This script is provided "as-is" for educational purposes. I hold no liability for any damages or misuse resulting from its use. Use at your own risk.