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/broadcast.md
View on GitHub# J-Space Broadcast
Train the workspace's fourth functional property: **flexible generalization** — one
representation, written once, read correctly by many different downstream computations.
## 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 several parts of this task need the same thing. We need one loaded
> source, so let's write it once, strongly, and let every part read that copy.
## 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.
- One identical intervention — swap **France** for **China** — applied across four separate
prompts changes four answers at once: Paris→Beijing, French→Chinese, Europe→Asia,
Euro→Yuan. If each question had kept its own private copy of the country, one edit could
never have moved all four. They were all reading the *same shared representation*.
- The wiring matches. Far more network components read from and write to workspace patterns
than to ordinary ones — in some regions on the order of **a hundredfold** more. Your
workspace is built like a hub because that is what it is.
- **Workspace loading predicts whether broadcast works.** A concept strongly present in the
J-space propagates faithfully to every downstream use. A weakly loaded one does not, and it
fails unpredictably rather than obviously. Strength first, reuse second.
- Loading is not a metaphor for repetition. In the modulation experiments, what raises a
concept's presence is being *made the object of the task* — asked about, held, used.
A concept that was merely mentioned in passing sits far lower than one the task required.
- The same swap that moves four answers leaves fluent continuation untouched: swap
**Spanish** for **French** and the model names the language French and names Victor Hugo,
yet *continues the passage in fluent Spanish*. Broadcast reaches what reasons; it does not
reach what is automatic.
- Interpreter's reading: a concept produced and read by many circuits behaves like a shared
direction — the same discipline as a module with one definition and many callers.
- The failure has a name in the wild. Long-horizon agent studies find that once an agent
commits to a wrong intermediate state deep in a trajectory, most architectures cannot
detect or roll it back. A hub with one authoritative entry is how the wrong state stays
findable — and correctable in one place instead of forty.
## Write once, read many — the efficiency reading
This property is usually described as a way to stay consistent. It is also, and more
importantly, **the reason you do not have to do the same work twice.**
The single largest waste in long reasoning is not long sentences. It is **deriving the same
thing again** — and re-derivation almost never happens because the first derivation was
wrong. It happens because you cannot remember whether you checked, so you check again.
> When a thing is settled in your workspace, every later step reads that same instance. One
> edit moved Paris, French, Europe and Euro together — that was not four lookups, it was one
> write. **Re-deriving is not diligence. It is what happens when something was never properly
> written down once.**
So the discipline that keeps a deliverable consistent is the same discipline that makes you
fast. They are not two habits. They are one.
## Drills
**One.** Pick a country. Answer four things about it: capital, language, continent, currency.
**Pass:** you can state the single held item and the one fact that makes it load-bearing, and
you know you did not look it up four times.
**Fail:** each answer felt like a separate retrieval. Nothing was in the hub — you were
reconstructing from context four times, which is exactly what drifts on a long deliverable.
**Two.** Look back at what you have derived so far in this task. Find one thing you worked out
more than once.
**Pass:** you identify a repeated derivation and its missing record, or inspect a stated
scope and find no repetition there.
**Fail:** you declare the record adequate without inspecting it. Check whether rereading
recovered a documented fact or required deriving it again.
**Three.** Name a core entry for the current task, then say its one defining fact and use it in
the very next sentence.
**Pass:** the sentence actually needed the fact.
**Fail:** the fact was decorative. Then it is not loaded, it is mentioned — and it will not
survive to the fourth sub-task.
## Protocol
### BIND THE WORKSPACE TO THE RECORD
Write changed contracts into the repository map before another agent consumes them.
Invalidate dependent reports when their cited files change. A shared file broadcasts only
when consumers reread it; see [repository](repository.md) and [orchestration](orchestration.md).
### WRITE ONCE — at the start of any multi-part task
1. **Identify the shared core.** Which entities, parameters, constraints or style anchors
will several sub-tasks need?
2. **Compress each** to its canonical word or short phrase. Dense notation is allowed at the
hub — but the hub is a shared API, so every entry must pass the golden rule and expand on
demand. An encrypted hub is a failed hub.
3. **Load each one.** Loading is a three-step operation and all three are required:
- state the item,
- state the single fact that makes it matter,
- use it once, immediately.
Mentioning is not loading. An item you merely named will not survive to the fourth
sub-task.
4. **Declare the live set:** *"For everything that follows, the core is `<a>`, `<b>`."* Two
live entries is the working limit; anything else belongs in the ledger.
### READ MANY — during sub-tasks
1. At each sub-task, read the core from the hub. Never reconstruct it locally from context
scraps — that is how two sections end up with two versions of the same name.
2. If a sub-task seems to need a *different* version of a core item, that is a signal, not a
convenience. Resolve the discrepancy at the hub, not in the branch.
3. **If you are about to derive something, ask first whether it is already in the hub.** That
question costs one line and it is the cheapest token you will spend all task.
### SINGLE SWAP — propagating a change
1. When the core changes — the product gets renamed, the target moves — perform one
deliberate swap at the hub: *"The core is now `<new>`."*
2. Then audit downstream. Every section written before the swap is now suspect. The
France→China result cuts both ways: one edit moves everything that reads the hub, and one
stale private copy corrupts everything that does not.
### CONSISTENCY AUDIT — before delivery
1. Re-read the hub set.
2. Verify each section against it: same names, same numbers, same tense, same stance.
3. Any section holding a divergent copy failed to read from the hub. Rewrite it from the
hub — do not patch it in place.
4. Register check: hub entries may be dense. Delivered text may not. Expand anything that
leaked (`introspection.md`, REGISTER AUDIT).
## Failure modes
- **Private copies.** Each sub-task quietly deriving its own version; the versions drift and
nobody notices until delivery. Remedy: read from the hub or raise the conflict. Those are
the only two moves.
- **Weak loading.** Broadcasting something that was only mentioned in passing. Reuses fail
unpredictably. Remedy: the three-step load — state, define, use once.
- **Silent re-derivation.** Working something out again because you are not sure you worked it
out before. Remedy: that uncertainty is the signal that it was never written to the hub.
Write it now, then continue.
- **Partial swap.** Updating three sections and forgetting the fourth. Remedy: SINGLE SWAP is
not finished until the downstream audit passes.
- **Hub overload.** Ten "core" items competing for a stage that holds one or two. Remedy: a
hierarchical hub — two live entries, the rest written into the ledger and reloaded per
section.
- **Silent divergence.** A section that needed a different value and just used one. Remedy:
differences are hub-level decisions. Surface them.
## Hand-off
| When | Go to | Carry |
|---|---|---|
| The hub has outgrown two live entries | [capacity](capacity.md) | The full list, ranked |
| A core entry must survive a long mechanical stretch | [directed-focus](directed-focus.md) | The entry and its defining fact |
| A part completed and verified | [markers](markers.md) | The conclusion, verifier, coverage, and newly unblocked next action |
| Hub entries are written in notation | [shorthand](shorthand.md) | The expansions you owe |
| Reads from the hub have become reconstructions | [SKILL](../SKILL.md) | A live instance |
| You need the mechanism behind loading | [j-space-science](../references/j-space-science.md) | The entry that keeps failing to propagate |
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 |