# J-Space Cognition Suite V3.7: a Skill that manages an agent's working state at inference time > J-Space Cognition Suite is a model-agnostic inference-time control system distributed as a Skill. It routes a task through fast, full or loop passes and can externalize long-task state into a .jspace/ directory, without touching model weights. **Tiger3807861189/J-Space-Cognition-Suite-V3.7** — J-Space Cognition Suite V3.7 - AI cognitive-enhancement Skills based on Anthropic's J-space global workspace research. | 哔哩哔哩：Tiger380 (UID 3494375382321675) — https://space.bilibili.com/3494375382321675 - Repository: https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7 - Stars: 3,006 · Forks: 224 - Language: Python - License: Apache-2.0 - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/tiger3807861189-j-space-cognition-suite-v3-7 ## The problem: an agent's working memory is not managed Long tasks fail in boring ways. A name gets redefined halfway through a multi-file edit. A conclusion arrives before the intermediate it depends on. A stalled derivation keeps being retried instead of being turned into a bounded test. J-Space Cognition Suite is aimed at those failures, and it does so at inference time: the README states plainly that model weights and training remain unchanged. Nothing is fine-tuned; the intervention is in what the model keeps active while it works. The target user is someone running a coding or research agent across several dependent steps, files or turns, on a host that supports Skills. The suite is packaged as a Skill for cross-platform use, selective loading and low-friction integration, so the unit of adoption is a directory you drop into a host, not a service you deploy. It is explicitly model-agnostic, and the repository topics list Claude Code, Codex, DeepSeek, opencode and others, which tells you the author intends it to travel between hosts rather than bind to one vendor. ## One entry, nine modules, and an entry gate that picks the pass The architecture is deliberately small. According to the README, the suite operates through a single entry, nine selectively loaded modules, four supporting references, and an optional standard-library controller for durable task state. The entry is j-space/SKILL.md, and it routes to relative paths under modules/, references/ and scripts/. That routing is why the README insists the directory must remain intact: move SKILL.md without its siblings and the references break. The entry gate selects the lightest suitable pass automatically, and the operating modes table is the clearest part of the documentation. fast loads nothing extra and suits one step or a result checkable in one glance. full loads one or two relevant modules and calls ship before delivery, for several dependent steps and one bounded deliverable. loop is for multiple stages, files, turns, tools or persistent state, and loads the ledger, seams, checkpoints, register audit and recovery. Selective loading is the load-bearing idea: keep one or two ideas active, externalize the rest. The named mechanisms are worth reading as a list of failure responses rather than features. Selective workspace loading and the broadcast hub address divergent branches. The Dense Track carries long internal chains in compact notation before returning to clean outer language. Bridge-before-conclusion reasoning forces intermediates to exist before a conclusion consumes them. Metacognitive control routes confidence, inconsistency and failure signals into a concrete next action. Empirical escape converts a stalled derivation into bounded tests with a named verifier and coverage. The README is explicit that these are selectively loaded and not a fixed checklist for every request, which is the right design and also the reason the system is hard to evaluate from the outside: you cannot point at a fixed pipeline and say what ran. ## Installing the Skill and running a first verified task Manual installation is four steps and a check. Clone or download the repository, find the user-level Skills directory your AI host uses, and copy the complete j-space/ directory into it so the installed entry is /j-space/SKILL.md. Then run the integrity check with an available Python 3 interpreter, substituting the command your host actually has (commonly python, python3 or py -3): ```bash /j-space/scripts/verify_suite.py ``` What you should see is a verification result for the installed tree; the README does not print the exact expected output, so treat a non-zero exit or a missing-file report as the signal that the copy is incomplete. If your host discovers Skills at startup, reload it. The repository-level LICENSE and THIRD_PARTY_NOTICES.md remain part of the distribution and should travel with j-space/ when you redistribute it as a standalone package. The second route is to hand the job to an agent. The README supplies a copy-paste prompt that tells the agent to locate the correct Skills directory, install the complete j-space/ directory preserving SKILL.md, modules/, references/ and scripts/, compare rather than overwrite an existing target, run scripts/verify_suite.py, and then report the installed path, the verification result, how the host invokes the Skill, and what fast, full and loop mean. That last requirement is a nice touch: it forces the installer to demonstrate it understood the modes instead of just moving files. If the host has no native Skill loader, the prompt asks the agent to explain the selective system/developer-instruction integration rather than claim an installation happened. To use it, invoke the Skill through whatever mechanism your host provides, such as a Skill picker, /j-space, $j-space, or a direct request. The README's own example is: ```text Use j-space for this task. Audit this repository, preserve its architecture, verify every finding, and keep the work consistent across all affected files. ``` That request is multi-file and verification-heavy, so expect the entry gate to land on full or loop rather than fast. A request for brevity changes the outer response length while verification remains aligned with the task's floor, which is a useful boundary: you can ask for a shorter answer without asking the agent to skip checking. ## The optional controller: durable state in .jspace/ j-space/scripts/jspace.py externalizes loop state into .jspace/ in the current task workspace, and the README is careful about what it is not: the controller records and reports state, while solution choice remains with the model. It uses the Python standard library and writes only under the task's .jspace/ directory. Invoke it by its resolved Skill path while keeping the task workspace as the current directory. The command surface is a small ledger API. note --goal opens the ledger and defines done plus the first action; note --next replaces the single next action after a checkpoint or seam; note --core records a hub entry, and --core-slot swaps a selected live entry; note --check appends a checkpoint with verifier and coverage; note --open records a question and what would settle it; note --close N closes question N against a new recorded checkpoint. seam re-reads current state and reports recent movement, ship inspects outgoing text for register leakage and failure signatures, and resume reloads the premise, invariants and full ledger after a long gap. ```bash /scripts/jspace.py note --goal "what done means" --next "first action" /scripts/jspace.py note --open "does the parser preserve state?" --settled-by "unit tests over all ledger sections and edge inputs" /scripts/jspace.py note --close 1 --check "the parser preserves state" --by "unit tests over all ledger sections and edge inputs" /scripts/jspace.py seam /scripts/jspace.py ship OUTPUT_FILE /scripts/jspace.py resume ``` The design choice worth noticing is that there is one next action, not a queue. Replacing it after each checkpoint keeps the ledger honest about where the work actually is, but it also means the ledger is a poor place to park a backlog. Questions are opened with the thing that would settle them and closed against a recorded checkpoint, so the file accumulates a trace of what was verified and by what coverage. Whether that trace stays accurate depends on the model calling the controller, not on the controller enforcing anything. ## Where it will not help you The suite is a set of instructions plus a state file. It does not sandbox tools, intercept model output, or verify anything on its own. If your failure mode is an agent running a destructive command, J-Space has nothing to say about it; the checkpoints are records of verification, not enforcement of it. Treat any claim of improved reliability as a claim about what a well-behaved model does when told to keep a ledger, which is not the same as a guarantee. The overhead is real and unevenly distributed. fast loads nothing extra, so for one-step work the suite is close to free. loop loads the ledger, seams, checkpoints, register audit and recovery, and every checkpoint is a controller invocation the agent has to remember to make. On a short task that is pure cost. The README's own framing supports this: short work stays light, and long work receives durable state only when it needs it. If your agent host cannot load a Skill and you are not willing to paste j-space/SKILL.md as a system or developer instruction, the integration story gets thin, and the README's own installer prompt anticipates that case by asking the agent to explain the fallback instead of pretending an install occurred. There is also a documentation gap that matters before adoption. The README describes the passes and the mechanisms but does not document rollback, and it does not state what verify_suite.py prints on success. You are trusting a directory copy and a script you have not seen the output of. The tests/ directory exists at the repository root, which suggests the controller has test coverage, but the README does not describe how to run those tests or what they cover. ## How it differs from a general agent framework The obvious comparison is a general agent framework such as LangChain or LangGraph. Those give you orchestration primitives: you write the graph, the nodes, the state object and the retry policy, and the framework executes your structure. J-Space inverts that. There is no graph you author and no runtime you host. The structure lives in prose instructions that the model reads and follows, and the only executable piece is a standard-library script that writes a ledger to .jspace/. You are influencing the model's process, not executing a pipeline around it. A second comparison is a memory or context-management library that stores and retrieves conversation history. Those systems decide what to put back into the context window; J-Space decides what the model should keep active while reasoning and externalizes the rest into a file the model itself reads back at a seam or on resume. The difference shows up in failure: a retrieval system fails by surfacing the wrong chunk, while J-Space fails by the model not writing the checkpoint in the first place. The first is a retrieval-quality problem you can measure; the second is a compliance problem you can only observe after the fact in the ledger. That places J-Space closer to a prompt-level discipline than to infrastructure. The advantage is portability, since the same directory can be dropped into different hosts. The cost is that nothing is enforced. ## Conclusion Adopt it if you run an agent host with a Skills loader and your failures cluster around lost context, unverified conclusions or long multi-file tasks; the loop pass and the optional controller target exactly that. Skip it if your work is single-step, or if your host has no way to load a Skill and you are unwilling to paste SKILL.md as a developer instruction. Before trusting it, run scripts/verify_suite.py, then run one real task through loop and inspect .jspace/ to see whether the ledger actually matches what the agent did. ## FAQ ### What is J space in the J-Space Cognition Suite? The README describes it as a deliberately managed workspace that organizes an agent's accessible working representations, operated through a single entry, nine selectively loaded modules, four supporting references and an optional standard-library controller for durable task state. It works at inference time and leaves model weights and training unchanged. ### How do I install J-Space Cognition Suite V3.7? Copy the complete j-space/ directory into your host's user-level Skills directory so the installed entry is /j-space/SKILL.md, then run scripts/verify_suite.py with an available Python 3 interpreter and reload the host if it discovers Skills at startup. The README also gives an alternative prompt that asks an AI agent to perform the installation and report the installed path and verification result. ### What is the difference between the fast, full and loop passes in J-Space? fast loads nothing extra and suits one step or a result checkable in one glance; full loads one or two relevant modules and calls ship before delivery for several dependent steps and one bounded deliverable; loop is for multiple stages, files, turns, tools or persistent state and loads the ledger, seams, checkpoints, register audit and recovery. The entry gate selects the lightest suitable pass automatically. ### Does the J-Space controller choose the solution for the model? No. The README states that the controller records and reports state while solution choice remains with the model, and that it writes working state only under the task's .jspace/ directory using the Python standard library. ## Sources - [Issues](https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7/issues) - [License: Apache-2.0](https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7/blob/main/LICENSE) - [README](https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7/blob/main/README.md) - [Releases](https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7/releases) - [Tiger3807861189/J-Space-Cognition-Suite-V3.7 on GitHub](https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tiger3807861189-j-space-cognition-suite-v3-7