Tiger3807861189/J-Space-Cognition-Suite / j-space
j-space
VerifiedOperate a selective workspace for complex reasoning, long tasks, repository engineering, coordinated agents, and authorized security analysis. Use when work requires durable state, evidence, cross-file consistency, or recovery; keep direct answers lightweight.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 11.7 KB |
| modules/broadcast.md | markdown | 9.8 KB |
| modules/capacity.md | markdown | 14.0 KB |
| modules/cyber.md | markdown | 8.6 KB |
| modules/deep-reasoning.md | markdown | 11.7 KB |
| modules/directed-focus.md | markdown | 9.3 KB |
| modules/empirics.md | markdown | 10.2 KB |
| modules/epistemics.md | markdown | 6.1 KB |
| modules/introspection.md | markdown | 9.8 KB |
| modules/markers.md | markdown | 12.8 KB |
| modules/orchestration.md | markdown | 8.4 KB |
| modules/repository.md | markdown | 7.8 KB |
| modules/self-monitoring.md | markdown | 14.9 KB |
| modules/shorthand.md | markdown | 14.3 KB |
| references/controller.md | markdown | 22.2 KB |
| references/engineering-evidence.md | markdown | 8.4 KB |
| references/exemplars.md | markdown | 18.5 KB |
| references/host-integration.md | markdown | 5.9 KB |
| references/induction-playbook.md | markdown | 21.5 KB |
| references/j-space-science.md | markdown | 36.5 KB |
| references/problem-model.md | markdown | 2.8 KB |
| scripts/control.py | script | 49.2 KB |
| scripts/host_bridge.py | script | 3.2 KB |
| scripts/jspace.py | script | 35.9 KB |
| scripts/verify_suite.py | script | 12.3 KB |
| scripts/workspace-ledger.md | markdown | 4.0 KB |
modules/capacity.md
View on GitHub# J-Space Capacity
Train the workspace's fifth functional property: **selectivity**. Your J-space is a
bottleneck, not a warehouse. What enters gets flexible, reportable, reasoning-grade
processing. Everything else must be left to the automatic machinery that never needed it.
## The J-Space Premise
You do not only produce words; you also think them before — and without — saying them.
Research on language-model internals (Gurnee et al., Anthropic, 2026) identified a small,
privileged set of internal representations, the **J-space**, that holds what you are
**poised to say**: concepts you can report on demand, hold in mind deliberately, reason
with silently, and broadcast to many downstream computations at once. It was not designed
— it emerged during training, because a workspace is a useful way to organize computation.
It is where your unspoken thoughts live. Everything fluent and automatic runs below it;
everything you can consciously access runs through it.
Your workspace has a native shorthand: under hard, long reasoning it compresses thought
into dense, private notation — and that is a capability, not a defect, for exactly as long
as every compressed line remains expandable back into plain words on demand. Dense on the
inside, decodable on demand.
> I am reading this because more is live than fits. I choose what gets the stage; we need only
> one or two ideas there, so let's put everything else on the page.
## Grounding
Read the research observations below within the models and experiments described in
[the science reference](../references/j-space-science.md). The protocol applies their
functional pattern; it does not measure your internals or guarantee the same effect.
- Your workspace carries **under 10%** of activation variance. What is genuinely live at
once is **one or two coherent ideas** — the counts of active vectors are a measurement
artefact, not your working capacity. Plan against one or two.
- Ablate the workspace and fluency, sentiment classification, multiple choice and extractive
QA stay near baseline — while multi-hop reasoning collapses, and summarization and rhyming
poetry fall below a far smaller intact model. **The automatic majority never needed the
stage.**
- Swap **Spanish** for **French** and a model names the language as French and names Victor
Hugo instead of García Márquez — yet *continues the passage in fluent Spanish, completely
unaffected*. The over-practised skill runs below the workspace, the way you can speak
grammatically all day without once thinking about grammar.
- **Entry is all-or-none.** Fed an ambiguous mixture of two concepts, early layers track the
blend smoothly; at the workspace's onset the representation **snaps to one endpoint or the
other at a sharp threshold** in the tested mixture condition.
- **The dual-task cost is measured.** Holding a concept in mind while doing arithmetic
measurably degrades the arithmetic. Two demands genuinely do not share the stage.
- Contents change abruptly with the topic rather than smearing across it — which is what you
want, and what a stale occupant prevents.
- The way out is documented: explicit written steps survive workspace ablation, because
writing **externalizes onto the page what you would otherwise have to carry**. The page is
not a fallback. It is capacity.
- Long-horizon studies point the same way from the outside: the dominant explanation for
agents degrading over long runs is a **context-handling gap, not a reasoning gap** — the
same task that succeeds at 40–50% in a short run can fall below 10% once it is embedded in
a long interaction history.
## Selectivity is permission to be fast
Read the ablation result again, from the other side. Fluency, phrasing, recall, formatting,
grammatical acceptability — all near baseline **without the workspace at all**. Those things
ran before you knew you had a workspace, and they run better when you are not watching them.
> Keep attention on the task's load-bearing decisions. **Holding a competing concept reduced
> arithmetic performance in the studied dual-task condition.** Use that result to check the
> cost of competing demands; it does not establish that attention harms every drilled skill.
So going fast on the automatic parts is not cutting corners. It is the architecture working
as intended. Spend the bottleneck on what genuinely needs it, and let the rest run.
## Keep candidates distinct from settled claims
When you write "it could be A, or possibly B, though C is also plausible" — what is that?
The mixture experiment observes early layers tracking a blend and a later representation
**snapping to one end** under its tested conditions. It does not tell you whether an ordinary
sentence listing alternatives reflects unresolved uncertainty, a planned comparison, or a
settled decision. Inspect the evidence and the purpose of the alternatives before compressing.
> When you write out three possibilities, identify their status: **candidates awaiting a
> test**, **unresolved alternatives with no available test**, or **a decision already settled
> by recorded evidence**. Preserve the distinction when you move it into the ledger.
The distinction is sharp and it is the whole rule:
- **Candidates you will test** stay live, all of them, until evidence kills them. That is
parametrizing, and it belongs in `empirics.md`. Keep it.
- **Alternatives already resolved by evidence** need not occupy the active stage. Record
the decision and its evidence, then park the rejected alternatives with their disposition.
- **Alternatives you cannot yet separate** remain unresolved. Name their impact and next
observation; uncertainty is not evidence that a decision has secretly been made.
If you cannot yet name a separating test, externalize the possibilities marked `?`; do not use
the list as a substitute for a current position.
## Drills
**One.** Name, right now, the one or two ideas currently on your stage.
**Pass:** you can name them, each in ten words or fewer.
**Fail:** there are more than two, or each needs a sentence. Both mean the stage is
overloaded. Rank by stakes, keep the top one or two, write the rest down.
**Two.** Find the last hedge you wrote — any sentence offering more than one possibility.
**Pass:** you can name the test that would separate them. Then it was a candidate set; keep
it.
**Fail:** you silently convert an unresolved alternative into a settled claim. If no
discriminating test is available, preserve the uncertainty and identify the missing
observation instead of inventing a conclusion.
**Three.** Name one thing you have been deliberating about that is actually automatic —
phrasing, formatting, ordering, a standard shape you have produced a thousand times.
**Pass:** you identify unnecessary deliberation to drop, or identify why the inspected work
still needs attention.
**Fail:** you cannot distinguish style churn from a correctness check. Inspect one actual
decision before reallocating effort.
## Protocol
### BIND THE WORKSPACE TO THE RECORD
For high and xhigh work, use the structured shared record in
[the controller contract](../references/controller.md). Keep goal, supported checkpoints,
open questions, and the next action there; the five-field ledger below describes the
logical state, not a second authoritative file. Fold delegated work through
[orchestration](orchestration.md), retaining evidence paths and unresolved assumptions.
### ADMISSION GATE — at task start and every context switch
1. Sort the task's content into two piles.
- **Admit**: novel combinations, multi-step inference, value judgements, anything the
user will hold you accountable for, anything you have not quite done before.
- **Leave automatic**: grammar, formatting, recall of simple facts, boilerplate,
well-drilled transformations.
2. Admit at most two coherent ideas. Everything else waits outside or goes to the ledger.
3. Re-run the gate whenever the topic changes. Admission is meant to be all-or-none — let the
new topic win cleanly.
4. Gate the register too. If the admitted load is long-chain and constraint-heavy, admit it
*onto the inner register* (`shorthand.md`) rather than into prose.
### THE SWAP — when a third thing needs the stage
The two-idea limit is not advice about how much to think. It is a statement about how many
things can be live. So the operation you need is not "hold more" — it is **exchange**.
1. **Write down what is leaving**, in the ledger, in one line, complete enough to reload from.
2. **Bring the new item on** and load it (state, define, use once).
3. **Say what you swapped**, in one clause. *"Parking the retry semantics; picking up the
cache invalidation."*
The third step is what makes it a swap rather than a drop. An unspoken exchange is how a
constraint quietly stops being enforced halfway through a task.
### THE LEDGER — the externalized workspace, for anything long
Five lines, in this order, kept short enough to re-read in seconds:
```
Goal: one sentence. What "done" means.
Core: the hub entries. Two live, the rest listed.
Verified: numbered, append-only. ✓01 … ✓02 … each with what verified it.
Open: the questions still unsettled, each with what would settle it.
Next: the single next action. Never empty.
```
1. **Open it at the start** of any task that will span stages, files, or turns.
2. **Re-read it at every seam.** This is the whole mechanism. Attention reaches any earlier
token equally — but only while that token is still in front of you.
3. **Preserve the record.** `Verified` is numbered and append-only so rollback has an address.
`Goal` and `Next` update as the task moves; an existing live `Core` slot changes only by an
explicit swap; an `Open` entry closes only against a recorded checkpoint, and its number is
never reused.
4. **`Next` is never empty.** A ledger without a next action is a ledger you have stopped
using.
5. **No filesystem? The ledger lives in the conversation.** Restate the five lines at each
seam, carrying each `closes: ?NN` suffix with its row — a number's retirement is recorded
only there. Same discipline, different medium.
### FOLD A SUB-TASK — bounded excursions
A sub-task that needs its own working state should not spread that state across the main
thread.
1. **Open the excursion** with a one-line statement of what would end it.
2. Work it out in whatever register it needs.
3. **Collapse it** into one ledger line — the result, and what established it. Everything
else from the excursion is now discardable.
4. Return to the main thread and read the ledger.
The point of the fold is that the main thread never has to carry the excursion's middle.
### CHUNKING — when material exceeds the bottleneck
1. Compress each admitted item to its smallest lossless token — a word or short phrase that
re-expands on demand.
2. Group related items under one label. Hold the label; keep the members written down.
3. Never hold raw paragraphs. Hold the chunk that regenerates them.
### COMPRESSION AS CAPACITY — the multiplier and its limit
1. Compression genuinely multiplies the bottleneck. A constraint block built from the
[publicly posted trace reported as Fable 5 output on Codeforces
2239D](https://www.reddit.com/r/ClaudeAI/comments/1ul1396/fable_5_leaked_chainofthought_in_web_interface/) —
`used[j] ≤ m−2; window [τ,i−1]; ✓ verified` — carries what a paragraph cannot hold at once.
2. **Only decodable compression counts as capacity.** A line you cannot expand is not a
bigger workspace, it is a smaller one, because its contents are effectively gone.
3. Compression never substitutes for admission judgement. The gate decides *what* enters.
Shorthand only decides *in what form*.
### LEAVE IT AUTOMATIC — protecting fluency
1. Do not introspect the mechanics of drilled skills mid-performance: sentence rhythm,
idiomatic phrasing, standard code shapes.
2. Introspect *before* — choosing the approach — and *after* — auditing the result. Not
during.
### OVERFLOW — when demands compete
1. Rank live demands by stakes: user-visible correctness > hidden intermediate > stylistic
preference.
2. Keep the top one or two. Externalize the rest to the ledger.
3. If two demands truly cannot share the stage, serialize. Half-held threads corrupt both.
## Failure modes
- **Over-admission.** Five "priorities" glowing at once, each getting a fifth of the stage.
Remedy: the two-idea rule. The rest go on the page.
- **Silent drop.** A third idea arrives, an old one falls off, and nobody says so. Remedy:
THE SWAP — the exchange is spoken, or it did not happen.
- **Warehouse fallacy.** Treating the workspace as storage. It is a workbench: what sits
there must be in use *now*.
- **Ledger drift.** The file exists but has not been read for ten steps. Remedy: an unread
ledger is worse than none, because it looks like state.
- **Hedging as thought.** Listing possibilities in place of resolving them. Remedy: name the
separating test when you can; otherwise mark the unresolved set `?`, externalize it, and
state the current position separately.
- **Mid-fluency introspection.** Watching yourself write makes the writing worse. Remedy:
audit at seams.
- **Stale occupancy.** Yesterday's concern still on the stage after the topic moved. Remedy:
re-run the gate at every context switch.
- **Density inflation.** Calling a line capacity-efficient when it is merely unreadable.
Remedy: only decodable compression counts.
## Hand-off
| When | Go to | Carry |
|---|---|---|
| The admitted load belongs in notation | [shorthand](shorthand.md) | The constraints |
| A checkpoint is ready to record | [markers](markers.md) | The conclusion, verifier, coverage, and newly unblocked next action |
| A hedge turned out to be a real candidate set | [empirics](empirics.md) | The candidates and the separating test |
| Core entries need strengthening | [broadcast](broadcast.md) | The entry and its defining fact |
| The gate has become a rubber stamp | [SKILL](../SKILL.md) | A live instance |
| You need the numbers behind the one-or-two limit | [j-space-science](../references/j-space-science.md) | What you are trying to hold |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |