J-Space Cognition Suite V3.7
Turns inference-time reasoning into a managed workspace: selective loading, a durable ledger, checkpoints, and recovery for deep reasoning, long tasks, and coordinated agents.
The skill is prompt/state-file driven; no excessive permissions, credential access, or covert exfiltration are visible. The cyber module explicitly requires authorized scope, negative controls, and evidence boundaries, and states the controller grants no authorization. Deductions: key scripts (scripts/control.py etc.) are absent from the reviewed material, so data flow and dependency behavior rest on prose alone; publisher is unverified; rollback and isolation depend on host behavior and cannot be statically confirmed.
Docs are self-consistent about degradation paths (conversation ledger without Python/filesystem), failure feedback, and abnormal input. Deductions: the executable core (control.py, jspace.py) is not provided, so arguments, schemas and key paths cannot be verified statically; no test suite or CI evidence; level-gate behavior depends heavily on model self-discipline and is non-deterministic.
Triggers, level gating, fit/non-fit boundaries and degradation conditions are clearly stated; core function needs only local Python 3.10+ and the filesystem, with no overseas-service dependency, so mainland-China use is unaffected. Deductions: all content is long-form English; trigger framing biases toward metacognitive tasks and risk of false invocation on ordinary short tasks, plus Chinese-scenario fit, is unaddressed.
Layered architecture (entry—modules—references) with good progressive disclosure, failure modes, boundary statements and repository Apache-2.0 license. Deductions: no version number, changelog, or maintenance-ownership statements visible in the skill itself; the citation 'Gurnee et al., Anthropic, 2026' has a suspicious, unverifiable date that weakens attribution; several referenced files are not present in the reviewed material.
Provides structured state tracking for long tasks, cross-file consistency and multi-agent coordination, plausibly useful. Deductions: all benefit claims are unverified; no execution or sample outputs exist; process overhead is substantial (frequent pulse/check/ledger maintenance) and marginal value over manually maintaining a state file is unevidenced, so a conservative low static score applies.
The text separates research observations from engineering claims and disclaims measuring internal activations — epistemically careful. Deductions: the core research citation is dated 2026 from Anthropic and is unverifiable with an anomalous date, bordering on fabricated provenance; the Codeforces trace rests on a Reddit link; no tests, CI, or third-party reproduction cover the skill's key paths, capping this dimension very low under static rules.
- The core research citation is dated as a 2026 Anthropic paper (Gurnee et al.); the date is anomalous and unverifiable — treat it as an unproven framing narrative, not established science.
- Executable components (scripts/control.py) were not provided in the reviewed material and nothing was executed in this assessment; audit script permissions and file-write scope before running.
- Benefits depend on the model voluntarily following a heavyweight process; for short tasks prefer level 'low' or a direct answer.
- Publisher identity is unverified by FollowSkills, and no version number or update path appears in the skill files; confirm maintenance status before adoption.
What does this skill do, and when should you use it?
J-Space Cognition Suite is a model-agnostic inference-time control system that changes nothing about weights or training, managing reasoning purely through prompts and scripts. It ships as one SKILL.md entry, nine selectively loaded modules, four references, and an optional standard-library Python controller. Its premise draws on Anthropic's interpretability research into a J-space global workspace, while explicitly separating research description from engineering claims. It targets work needing durable state, cross-file consistency, verification, and recovery, while keeping simple requests lightweight.
The SKILL.md entry runs a level gate (low/medium/high/xhigh) deciding how many modules load and whether agents coordinate. At high/xhigh it maintains .jspace/control. plus a human-readable .jspace/CONTROL.md via scripts/control.py, recording goal, evidence, checkpoints, agent reports, and the next action; pulse forces real file rereads at tool boundaries instead of trusting memory. Nine modules route signals such as introspection, directed focus, deep reasoning, broadcast, capacity, self-monitoring, shorthand, markers, and empirics, with additional repository-engineering and authorized-security modules. An optional jspace.py offers a standalone ledger and a ship output check; verify_suite.py validates installation integrity.
- Developers making multi-file, multi-stage changes where architecture must stay consistent, such as a whole-repo audit or large refactor
- Long-horizon task runners whose sessions lose context and need checkpoints plus resume
- Agent coordinators who must independently verify every delegated result
- Security researchers handling authorized analysis that requires reproduction and a negative control
- Chat/API users on hosts without Python or a filesystem who still want a conversational ledger, accepting degraded persistence
What are this skill's strengths and limitations?
- Model-agnostic: effects reproduced across DeepSeek, Qwen, GLM, GPT, and Claude families; the protocol itself is the portable unit
- Inference-time only; weights untouched, and light requests stay light while heavy work loads modules
- Optional controller uses only the Python standard library and writes state solely under the task's .jspace/
- Explicit research/engineering evidence-boundary docs avoid overclaiming; Apache-2.0 with CI and regression tests
- The README's +J-Space benchmark column is flagged as estimated from limited controlled experiments; speed/token figures come from a single GAIA pair
- Advanced features need executable Python and a filesystem; without them only a degraded conversational ledger works, and a portable skill cannot interrupt a host that never calls it
- Gates, seams, and invariants impose a learning curve on casual users
- Tunables like the refresh interval are engineering starting points, not measured optima, and require manual adjustment
How do you install this skill?
1) Clone or download https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7; 2) locate your host's user-level Skills directory; 3) copy the complete j-space/ directory so the entry is <skills-directory>/j-space/SKILL.md (the structure must stay intact because modules load via relative paths); 4) run <python> <skills-directory>/j-space/scripts/verify_suite.py to check integrity; 5) reload the host if it discovers Skills at startup. Alternatively, paste the repo's English install prompt into an agent with file access and let it install; if a j-space target exists it must compare and ask before replacing. When redistributing j-space/ alone, carry the root LICENSE and THIRD_PARTY_NOTICES.md with it.
How do you use this skill?
Invoke via your host's Skill mechanism (picker, /j-space, $j-space, or a direct request), e.g.: "Use j-space for this task. Audit this repository, preserve its architecture, verify every finding, and keep the work consistent across all affected files." The entry gate picks the lightest suitable pass (fast/full/loop or low/medium/high/xhigh) automatically. At loop level, keep the task directory as cwd and run scripts/control.py subcommands (init/read/pulse/check, etc.); without Python or a filesystem, follow the suite's guidance to restate the ledger fields in conversation and explicitly report that persistence is unavailable.
How does this skill compare with similar options?
The README benchmarks it against raw frontier models (e.g., Opus-5, Fable 5.1, GLM-5.3), positioning it as an inference-time control layer atop any model rather than a replacement for a named competing product; no other similar Skill products are named.