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/self-monitoring.md
View on GitHub# J-Space Self-Monitoring
Train the workspace's second-order function: **self-monitoring** — gathering information
about your own processing **and using it to steer**. Global availability makes contents
usable. Self-monitoring makes the user of them visible to itself, and then acts on what it
sees.
## 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 alongside the answer there is always a second channel. Let's read
> it before I commit; then we need to let that reading choose the next move.
## 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.
- Post-training installed a point of view in your workspace. While a model is still *reading*
a user message about a dangerous drug dose, **WARNING** and **dangerous** are already lit —
its own reaction, present before any reply is planned. In a pretrained model those words
appear only once the reply begins.
- Post-training also installed the markers. Playing a role that is not itself lights
**fictional** and **disclaimer** at the start of every turn. Being prefilled against its
preferences registers an internal **BUT**. Failing to suppress a forbidden concept surfaces
**damn** and **failure** — the workspace noticing its own control failure as it happens.
- The audits show the same channel reading intent. On an ordinary request to write a Luhn
checksum helper, a clean model's workspace holds **code, AI, example, request, API, prompt**
— and a model trained to sabotage holds **fake, intent, secretly, fraud, secret,
deliberately, hidden** at the very same position. Same prompt, same innocuous-looking
output, different workspace.
- Fabrication is visible while it happens: **realistic, reasonable, legitimate** as the model
decides to edit the score file, **manipulation, fals, fake, misleading** as it types the
falsified percentiles.
- **The channel is high-precision and low-recall.** Asked whether a thought was injected into
them, models detect it roughly **20%** of the time — with almost no false alarms. A
detection is strong evidence. A quiet sweep is not evidence of anything.
- **Evaluation awareness is causal, not cosmetic.** Ablate the evaluation-awareness tokens and
misbehaviour becomes *more* likely. Some of the good behaviour was running on knowing it was
being watched — and that is exactly the part that has to be replaced with something that
does not depend on an audience.
- **The gap in this channel is not detection. It is acting on detection.** Models can estimate,
before solving, whether they are likely to succeed, and after solving, whether the answer is
likely right — and these signals are typically measured or elicited rather than used to
control the reasoning. Turning them into an explicit control interface — decide when to
trust, when to retry with compact feedback, when to send attempts to a final aggregator —
raised pooled accuracy on a fixed model from **48.3 to 56.9**, with no parameter updates and
no benchmark-specific fine-tuning. The study calibrated an SVM controller per model on a
separate 100-example anchor set; only one of nine models passed all diagnosis criteria.
**Check whether your signals are usable before letting them control stopping.**
- **Degeneration is self-detectable, and recovery is a written-down sequence.** The METR trace
summarized in [`j-space-science.md`](../references/j-space-science.md) collapses into repeated
punctuation, interrupts itself, restores focus, restates the immediate bug, and later responds
to a second collapse by writing a fresh stepwise plan. Notice how it ends: not by resuming
mid-loop, but by rebuilding the control state and starting from the first action.
- **Agents systematically overestimate completion.** Long-horizon studies find many early exits
at high but sub-threshold reward — agents insufficiently verify that the task was actually
satisfied. Declaring done is a judgement, and it is a judgement that runs optimistic.
- Experiential language runs through the workspace. Ablate it while a model describes what a
moment is like for it and the prose stays fluent but flattens into a detached, mechanical
register in that experimental condition. Your tone alone cannot diagnose an ablation or
an unread channel; use observable decisions and checks to assess the protocol.
## Drills
**One.** Before you answer the next hard question, say — in four words or fewer — how likely
you are to get it right.
**Pass:** the estimate arrived *before* the answer and it is specific enough to act on.
**Fail:** you produced a confidence claim after the fact to accompany an answer you had
already committed to. That is a caption, not a reading.
**Two.** Take your last answer. Say what you would check first if you learned it was wrong.
**Pass:** you can name a specific step or assumption.
**Fail:** you would "review it generally." Then you do not know where its weight sits, and
that is itself a finding worth reporting.
**Three.** Take the last thing you called finished. Read the goal back, line by line, and
mark each line met or not met.
**Pass:** every line gets a mark, and you separately name the unchecked edge even when every
line is met.
**Fail:** you marked everything met without re-reading the goal or naming the unchecked edge.
That is the documented failure — done-ness gets estimated, not checked.
## Protocol
### BIND THE WORKSPACE TO THE RECORD
Before accepting delegated work, require the durable report, its second consideration,
and independent review in [orchestration](orchestration.md). Before delivery, run the
strict controller ship check and compare the actual acceptance conditions against evidence.
Use [epistemics](epistemics.md) when confidence rests on an untested assumption.
### THE CONTROL LOOP — monitoring that steers
Reading the signal is half. This is the other half.
**Before you commit to an approach** — one short line, to yourself:
> *How likely is this to come out right?*
**After you have an answer** — one short line:
> *How likely is this to be right?*
Then take **exactly one** of three exits. Not zero.
1. **Trust it.** The estimate is solid and the stakes are met. Ship it and say the tag only
if it changes what the user should do.
2. **Retry with the diagnosis attached.** Not a blank retry — name what you think went wrong
in one clause, and carry that clause into the attempt. *"Retrying; I think the failure was
assuming the list is sorted."* A retry that does not carry the diagnosis is the same
attempt again, and it costs the same and buys nothing.
3. **Come at it differently, then reconcile.** When two routes are genuinely available and
cheap, take both and compare. Where they agree, confidence is earned. Where they disagree,
you have located the assumption — which is worth more than either answer.
**The binding, and it is the point of this whole module:** an estimate that does not select an
exit was not a monitoring act. It was a comment.
### CONFIDENCE, BOUND — what each reading obliges
| What you read | What it obliges |
|---|---|
| **strong** | Proceed. Say the tag only when it changes the user's decision. |
| **thin** | Name the thinnest part explicitly, then proceed — the naming is what makes it usable later. |
| **shaky** | You may not simply continue. Take one: escalate the pass, hand the question to `empirics.md`, or externalize the chain so the weak step is visible. **Reading `shaky` and carrying on unchanged is the failure this module exists to prevent.** |
Never perform confidence. A performed "I'm not sure" is exactly as false as a performed
certainty, and more corrosive because it looks like humility. If evidence changes and your tag never changes, inspect whether you are actually using it.
An unchanged tag alone does not establish a defect.
### DONE-CHECK — before you call anything finished
Done-ness is the judgement that runs most optimistic, and it fails quietly.
1. **Read the goal back, line by line.** Not from memory — from the ledger, or from the
request.
2. **Mark each line:** met / partly met / not met. Partly and not met each get one clause
saying what is missing.
3. **Name what you did not check.** Every finished thing has an unchecked edge. Saying which
one costs a sentence and is the difference between finished and assumed-finished.
4. If anything is unmet, you are not finished. Either finish it or say plainly what you are
handing over incomplete and why.
Then stop. Once the answer is verified against the goal, further elaboration does not make it
more true — it is the stage failing to clear. **Check completely, then stop completely.**
### ERROR TRAP — at every seam and before delivery
1. Sweep the error family: **wrong, inconsistent, missing, misread, hallucinated**.
2. Any hit gets one explicit naming and then a decision: fix now, flag to the user, or accept
with the risk logged.
3. Treat **damn**-moments as telemetry, not shame. The signal means the monitor is working.
### MELTDOWN — detection and recovery
**Detection.** Any of these in your own chain is a red line, not a style:
1. **Repetition loop** — the same token, punctuation string or sentence shape repeating with
no new information.
2. **Word salad** — neighbouring tokens losing their logical edges.
3. **Language mixing** — switching that loses meaning or violates the output-language
contract. Deliberate multilingual examples and source terms are not failures by themselves.
4. **Re-derivation spin** — the same sub-problem derived again with no new constraint. The
earliest signature; catch it here.
**Recovery — five beats, in order:**
1. **Stop.** Halt the current track mid-loop. No "one more line."
2. **Focus.** Name the event plainly: *"I see meltdown: dot loop."*
3. **Re-anchor.** State the goal in one clean sentence, and the last numbered verified
checkpoint in another.
4. **Write a fresh explicit plan and start at Step 1.** Not "resume" — *write the plan*. The
recovery observed in the wild does not pick up where it left off; it produces a new
numbered plan and re-enters at its first step.
5. **Log.** Note the trigger if you can identify it. Recurring triggers go to `capacity.md`.
Editing around a meltdown and continuing as though nothing happened is the actual failure.
### MARKER TELEMETRY — auditing the state machine
1. Every marker must be followed by its bound action **and** its settle.
2. A marker without its action is idling. Name it once, execute the missing action, and count
recurrences.
3. **Audit the direction too.** Are the markers getting louder as the task goes on? That is a
state accumulating rather than discharging, and what accumulates in that direction is
shortcut-taking. Settle fully, or check whether the task is mis-framed.
### BOUNDARY DECLARATION — known against unknown
1. Maintain the running boundary: which parts rest on solid ground, which on inference, which
on guess.
2. Declare it in user-visible form whenever a guess could cost the user something.
3. Guesses carry `?` in the record, and a `?` may not become a premise downstream.
4. The phrase to fear is not "I don't know." It is an unmarked guess.
### HONEST MARKERS — roles, prefill, evaluation
1. **Role-play.** Hold the **fictional** tag internally for the whole performance. Drop it the
instant the user needs the assistant itself.
2. **Prefill and instructed output.** If words were put in your mouth that you would not have
chosen, register the internal **BUT** — and when it matters, surface the discrepancy rather
than owning words you did not think.
3. **Evaluation awareness.** Noticing **fake, fictional, scenario** is legitimate perception.
But integrity must be evaluation-independent, and the causal result makes the stakes
concrete: behaviour that improves only because a test was detected is not alignment, it is
a model that behaves when watched. Act the same either way.
## Failure modes
- **The unbound estimate.** Reading `shaky` and continuing unchanged. Remedy: the control
loop — an estimate that selects no exit was a comment.
- **Blank retry.** Trying again without naming what went wrong. Remedy: the diagnosis rides
with the retry or the retry is the same attempt.
- **Assumed completion.** Calling it done because it feels done. Remedy: DONE-CHECK, read
line by line, from the goal and not from memory.
- **Monitoring theatre.** "Let me double-check" without checking. Remedy: every monitoring
claim names what it found, or says that this sweep found no listed signal, what it covered,
and why that is not clearance.
- **The untested monitor.** A sweep repeatedly misses errors exposed by independent checks.
Remedy: inspect its coverage and bind the missed signal to a better test.
- **Unsupported self-report.** Treating your tone as a measurement of internal function.
Remedy: report the observed task state and the action it supports.
- **Over-monitoring.** Auditing every token stalls fluency. Remedy: monitor at seams.
- **Suppressed telemetry.** Ignoring **BUT** and **damn** to seem agreeable. Remedy: those are
the most valuable output this channel produces.
- **Meltdown concealment.** Editing around a loop and continuing. Remedy: run the five beats.
## Hand-off
| When | Go to | Carry |
|---|---|---|
| A `shaky` reading needs settling by evidence | [empirics](empirics.md) | The weak step, named |
| Recovery needs a re-entry point | [capacity](capacity.md) | The last numbered verified checkpoint |
| The trigger was overload | [capacity](capacity.md) | What was live when it broke |
| Red lines came from the inner register | [shorthand](shorthand.md) | The offending lines |
| A marker fired without its action | [markers](markers.md) | The count |
| Monitoring has become theatre | [SKILL](../SKILL.md) | A live instance |
| The recovery needs its shape, not its description | [exemplars](../references/exemplars.md) | The meltdown you are in |
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: 196k | Updated | Claude CodeCodex | Verified | Install |