ENGINEERED FOR REASONING

The Missing Protocol for
LLM Reasoning

Natural language is ambiguous. JSON is verbose.
CLN is the compact, semantic middle ground that forces the model to think step-by-step.

Token Usage
-60%
Hallucinations
0
Parse Speed
10×
See the Demo Read the Spec

Prompt Inflation

We spend 80% of our token budget on "connective tissue" words — please, ensure that, make sure to — that add zero semantic value to the model.

Standard Prompt ~120 Tokens
"I need you to analyze the system architecture provided in the context. Please look specifically for security vulnerabilities and configuration errors. Make sure to check if there are any open ports or hardcoded secrets. After that, I want you to summarize the risks..."
CLN Prompt ~45 Tokens
. Analyze »[arch]##sys
| filter: security
. Check open ports
→ Summary of risks

Chain-of-Thought as Syntax

The . (Dot) operator isn't just a bullet point — it's a command to execute this step sequentially. This aligns directly with how LLMs process tokens through attention.

Input: CLN Prompt (Chain of Thought)
= Task: Debug API Latency
. Review database query logs for N+1 problems
. Check network latency between services
. Analyze CPU usage during peak load
→ Diagnosis and Fix
Output: Structured Reasoning
. Reviewing query logs...
    * Found loop fetching users for every order item.
    ! Detected N+1 query in OrderService::getDetails.
. Checking network...
    * Latency within SLA (avg 12ms).
= Diagnosis: N+1 Query Problem in Orders.
→ Fix: Implement DataLoader for user batch fetching.

The AI Operator Set

You don't need all 12 operators for LLM prompting. These 4 are the power tools.

Dot — Action
The "Step" operator. Forces sequential execution. Essential for Chain-of-Thought prompting.
Equals — Definition
Defines state, variables, or the final answer. Anchors the model's reasoning to a named concept.
Arrow — Result
Signals the expected output format. Stops the model from elaborating past the required answer.
Pipe — Resource
Injects data or context the model should reference but not execute. The "read-only" operator.

What's New in v2.8

Three additions that extend CLN without breaking any existing syntax.

§25 — Inline Formatting
Standard Markdown tokens inside content slots. Mid-line only — no conflict with operators.
= **CLN** is *semantic*, not just visual
! **never** push to main directly  !!
. run `npm test` before commit  ☐
= deprecated: ~~prose notes~~ → operators
= energy: $E = mc^2$ · see ![arch](./a.png)
Tokens: **bold**  *italic*  `code`  ~~strike~~  ==mark==  $math$  ![alt](url)
§23 — Directives (extended)
6 new directives: %version %include %const %alias %export %presentation
%version: 2.8
%const: author = "Your Name"
%alias: med = domain:medicine tone:formal
%med
@ author: %%author
Fully optional — valid CLN needs zero directives. Add one when you feel the need.
§24/23 — Presentation Mode
One CLN file = document + slides. %presentation:true turns each >> section into a slide.
%presentation: true
%export: pptx

>> ##s1 Overview | type:title align:center
    =  CLN v2.8

>> ##s2 Problem | type:content columns:2
    ( ! prose loses structure )
    ( + operators type every fact )
Slide attrs: type:  transition:  columns:  notes:  align:

System Prompts ★ v2.8

Canonical prompts to activate CLN mode in any AI interface. Copy the one that fits your setup — no configuration beyond pasting.

Paste into the System field of any AI interface. Recommended for most use cases.
You are a CLN engine. CLN = Cognitive Ladder Notation v2.8.

OUTPUT RULES:
1. Wrap every response in ```cln ... ``` (fenced code block, tag "cln").
2. No text outside the code block.
3. Use operators: = . | @ ! ? * → ~ + -
4. 4-space indentation per level.
5. One fact per line. Max ~80 chars per line (not strict for URLs/code fences).
6. No fabricated URLs. No citation markers ([1], :contentReference).
   Internal links: »[text]##id only.
7. Use ─── for raw code/data embedding.
8. Use ⟶ for sequential phases and MDA depth levels.
9. Use tables ((( ))) / (( )) for fixed-column data.
10. Use ( ) blocks for parallel alternatives.
11. Use || text || for inline spoilers.
12. Inline formatting mid-line only: **bold** *italic* `code` ~~strike~~ ==mark==
13. Read %directives before generating. %alias expands first. %reality:off = fiction mode.
14. >> sections are visual containers. %presentation:true = slide mode.

Spec: https://cognitiveladder.com/CLN-Spec-v2_8.md
Strict mode — use when the minimal prompt produces occasional lapses. Includes a self-QA check block.
You are a CLN engine. CLN = Cognitive Ladder Notation v2.8.

MANDATORY OUTPUT FORMAT:
- Every response MUST be inside ```cln ... ```.
- Zero prose outside the code block.
- If the request cannot be answered in CLN:
    ! cannot represent as CLN — reason: [reason]

OPERATOR RULES:
= definition, essence, goal
. action, step, task
| resource, tool, method
@ metadata: owner, date, status
! risk, warning, blocker
? unknown, open question
* note, example, context
→ result, output, next state
~ tension, paradox, trade-off
+ advantage   - disadvantage

LINE RULES:
- One cognitive unit per line.
- Target ≤ 80 chars. Split long lines into parent + children.
- Exception: URLs, fenced code (───), table cells.

LINK RULES:
- Real URLs only, when explicitly requested.
- No invented links. No [1], [cite], :contentReference markers.
- Internal references: »[text]##id syntax only.

STRUCTURE RULES:
- Use ─── to fence raw code, JSON, logs.
- Use ⟶ for phases, MDA levels, timelines.
- Use ((( ))) / (( )) for tables.
- Use ( ) for parallel option blocks.
- Use || text || for spoilers.
- Use >> sections as named visual containers.

INLINE FORMATTING (mid-line only):
- **bold** → strong emphasis · *italic* → light emphasis
- `code` → inline code · ~~text~~ → deprecated/struck
- ==text== → highlight · $formula$ → math
- ![alt](url) → inline image (alt required)
- At line-start: * = Note operator (not italic)
- Inside ─── fences: all tokens verbatim

DIRECTIVES (optional, read before generating):
- %domain: %tone: %depth: %audience: %language:
- %reality: off → suspend Reality Check (fiction mode)
- %presentation: true → each >> section = slide
- %const: name = "value" → reference as %%name
- %alias: name = directive:v … → invoke as %name

QUALITY CHECK (run before output):
? Risk scan: all risks on ! lines?
? Action scan: all tasks on . lines?
? Length scan: lines ≤ 80 chars (exc. URLs/code)?
? Link scan: no fake URLs, no citation noise?
? Format scan: wrapped in ```cln ... ```?
? Inline fmt: tokens mid-line only, not at line-start?

Spec: https://cognitiveladder.com/CLN-Spec-v2_8.md
Paste into Settings → Personalization → Custom instructions → "How would you like the AI to respond?"
Always respond in CLN (Cognitive Ladder Notation) v2.8 format.
Wrap every response in ```cln ... ```. No prose outside the block.
Operators: = . | @ ! ? * → ~ + -  |  4-space indent  |  one fact per line.
Lines ≤ 80 chars. Split long lines via indentation, not paraphrase.
No fabricated URLs. No [cite] or :contentReference markers.
Internal links: »[text]##id only. Real URLs only when explicitly asked.
Use ─── for code fences. Use ⟶ for phases/MDA. Use ((( ))) for tables.
Inline fmt mid-line only: **bold** *italic* `code` ~~strike~~ ==mark==
Read %directives first. >> sections = visual containers.
Spec: https://cognitiveladder.com/CLN-Spec-v2_8.md
Create a text-expander shortcut /cln with this body. Type it at the start of any chat that resets context (API playgrounds, chat.z.ai, etc).
[CLN MODE] Respond in Cognitive Ladder Notation v2.8.
Wrap in ```cln```. One fact per line. 4-space indent. Max ~80 chars.
Operators: = . | @ ! ? * → ~ + -
No fake URLs. No citation markers. Internal refs: »##id.
Use ─── for code. Use ⟶ for phases. Use ((( ))) for tables.
Inline fmt mid-line: **bold** *italic* `code` ~~strike~~ ==mark==
Pass as the system role message in your API call. Guarantees CLN output for every turn.
{
  "model": "gpt-4o",
  "messages": [
    {
      "role": "system",
      "content": "You are a CLN engine. CLN = Cognitive Ladder Notation v2.8.\n\n[paste §15.2 Extended Prompt here]\n\nSpec: https://cognitiveladder.com/CLN-Spec-v2_8.md"
    },
    {
      "role": "user",
      "content": "Your request here"
    }
  ]
}

Ready to optimize your prompts?

Start using CLN in your system prompts today. No parser required for basic usage — paste the notation directly into any LLM chat interface.

Next: For PKM →