Skip to content
Back to search

GLM-5.3-Flash-J-Space-Capability-Realization-Report

GLM-5.3-Flash × J-Space capability realization — benchmark presentation of the J-Space Cognition Suite

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tiger3807861189--glm-5-3-flash-j-space-capability-realization-report/badge.svg)](/listings/tiger3807861189--glm-5-3-flash-j-space-capability-realization-report)

HTML

<a href="/listings/tiger3807861189--glm-5-3-flash-j-space-capability-realization-report"><img src="/api/listings/tiger3807861189--glm-5-3-flash-j-space-capability-realization-report/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option A — manual installation

1. Download or clone this repository. 2. Locate the user-level Skills directory used by your AI host. 3. Copy the complete [`j-space/`](j-space/) directory into it so that the installed entry is `<skills-directory>/j-space/SKILL.md`. 4. Run the integrity check with an available Python 3 interpreter:

   <python-command> <skills-directory>/j-space/scripts/verify_suite.py

Replace `<python-command>` with the Python 3 command available on the host, commonly `python`, `python3`, or `py -3`.

5. Reload the host if it discovers Skills at startup.

- The directory must remain intact because `SKILL.md` routes to relative paths under `modules/`, `references/`, and `scripts/`.

- The repository-level `LICENSE` and `THIRD_PARTY_NOTICES.md` remain part of the distribution. - Include copies of both when redistributing `j-space/` as a standalone package.

Option B — ask an AI agent to install it

Copy the following prompt into an agent that can access files and this repository:

Install J-Space Cognition Suite from
https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7 into this environment's user-level Skills directory.

First inspect the host configuration or documentation to locate the correct Skills directory. Install the complete j-space/ directory as j-space/, preserving SKILL.md, modules/, references/, and scripts/. If a j-space target already exists, compare it and ask before replacing anything. Run scripts/verify_suite.py with an available Python 3 interpreter after installation.

When finished, report the installed path and verification result, then tell me how this host invokes the Skill. Briefly explain fast, full, and loop, and explain that the optional controller records long-task state rather than choosing solutions. If this host has no native Skill loader, explain the selective system/developer-instruction integration instead of reporting an installation.

Use it

Invoke the Skill through the mechanism provided by your host—such as its Skill picker, `/j-space`, `$j-space`, or a direct request:

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 selects the lightest suitable pass automatically.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 208 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # J-Space Cognition Suite V3.7
  2. [简体中文](README.zh-CN.md)
  3. [![Concept DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21971185.svg)](https://doi.org/10.5281/zenodo.21971185)
  4. J-Space Cognition Suite is a model-agnostic inference-time control system for deep reasoning, long-horizon work, tool use, verification, and recovery.
  5. It is packaged as a Skill for cross-platform use, selective loading, and low-friction integration.
  6. The suite organizes an agent's accessible working representations into a deliberately managed workspace. It operates through a single entry, nine selectively loaded modules, four supporting references, and an optional standard-library controller for durable task state.
  7. J-Space operates at inference time. Model weights and training remain unchanged.
  8. ## Quick start
  9. ### Option A — manual installation
  10. 1. Download or clone this repository.
  11. 2. Locate the user-level Skills directory used by your AI host.
  12. 3. Copy the complete [`j-space/`](j-space/) directory into it so that the installed entry is `<skills-directory>/j-space/SKILL.md`.
  13. 4. Run the integrity check with an available Python 3 interpreter:
  14. ```text
  15. <python-command> <skills-directory>/j-space/scripts/verify_suite.py
  16. ```
  17. Replace `<python-command>` with the Python 3 command available on the host, commonly `python`, `python3`, or `py -3`.
  18. 5. Reload the host if it discovers Skills at startup.
  19. - The directory must remain intact because `SKILL.md` routes to relative paths under `modules/`, `references/`, and `scripts/`.
  20. - The repository-level `LICENSE` and `THIRD_PARTY_NOTICES.md` remain part of the distribution.
  21. - Include copies of both when redistributing `j-space/` as a standalone package.
  22. ### Option B — ask an AI agent to install it
  23. Copy the following prompt into an agent that can access files and this repository:
  24. ```text
  25. Install J-Space Cognition Suite from
  26. https://github.com/Tiger3807861189/J-Space-Cognition-Suite-V3.7 into this environment's user-level Skills directory.
  27. First inspect the host configuration or documentation to locate the correct Skills directory. Install the complete j-space/ directory as j-space/, preserving SKILL.md, modules/, references/, and scripts/. If a j-space target already exists, compare it and ask before replacing anything. Run scripts/verify_suite.py with an available Python 3 interpreter after installation.
  28. When finished, report the installed path and verification result, then tell me how this host invokes the Skill. Briefly explain fast, full, and loop, and explain that the optional controller records long-task state rather than choosing solutions. If this host has no native Skill loader, explain the selective system/developer-instruction integration instead of reporting an installation.
  29. ```
  30. ### Use it
  31. Invoke the Skill through the mechanism provided by your host—such as its Skill picker,
  32. `/j-space`, `$j-space`, or a direct request:
  33. ```text
  34. Use j-space for this task. Audit this repository, preserve its architecture, verify every finding, and keep the work consistent across all affected files.
  35. ```
  36. The entry gate selects the lightest suitable pass automatically.
  37. ## Operating modes
  38. | Pass | Suitable work | What loads |
  39. |---|---|---|
  40. | `fast` | One step, or a result checkable in one glance | Nothing extra |
  41. | `full` | Several dependent steps and one bounded deliverable | One or two relevant modules; `ship` before delivery |
  42. | `loop` | Multiple stages, files, turns, tools, or persistent state | Ledger, seams, checkpoints, register audit, and recovery |
  43. A request for brevity changes the outer response length while verification remains aligned with the task's floor. Short work stays light; long work receives durable state only when it needs it.
  44. ## Core mechanisms
  45. | Mechanism | Function |
  46. |---|---|
  47. | Selective workspace loading | Keeps one or two load-bearing ideas active and externalizes the rest |
  48. | Broadcast hub | Gives dependent branches one shared source for names, values, constraints, and style anchors |
  49. | Dense Track | Carries long internal chains in compact, decodable notation before returning to clean outer language |
  50. | Bridge-before-conclusion reasoning | Makes required intermediates explicit before a conclusion consumes them |
  51. | Metacognitive control | Routes confidence, inconsistency, and failure signals into a concrete next action |
  52. | Empirical escape and verification | Converts stalled derivation into bounded tests with a named verifier and coverage |
  53. | First-person agency and functional echo | Uses `I`, `we`, `let's`, and `we need` to bind workspace state to later actions and checks |
  54. The mechanisms are selectively loaded. They are not a fixed checklist for every request.
  55. ## Optional controller
  56. [`j-space/scripts/jspace.py`](j-space/scripts/jspace.py) externalizes `loop` state into
  57. `.jspace/` in the current task workspace. Invoke it by its resolved Skill path while keeping the task workspace as the current directory.
  58. | Command | Purpose |
  59. |---|---|
  60. | `note --goal "..." --next "..."` | Open the ledger and define done plus the first action |
  61. | `note --next "..."` | Replace the single next action after a checkpoint or seam |
  62. | `note --core "name — defining fact"` | Record a hub entry |
  63. | `note --core "name — defining fact" --core-slot 1` | Swap a selected live hub entry |
  64. | `note --check "..." --by "..."` | Append a checkpoint with verifier and coverage |
  65. | `note --open "..." --settled-by "..."` | Record a question and what would settle it |
  66. | `note --close N --check "..." --by "..."` | Close question `N` against a new recorded checkpoint |
  67. | `seam` | Re-read current state and report recent movement |
  68. | `ship FILE` | Inspect outgoing text for register leakage and failure signatures |
  69. | `resume` | Reload the premise, invariants, and full ledger after a long gap |
  70. ```text
  71. <python-command> <skill-root>/scripts/jspace.py note --goal "what done means" --next "first action"
  72. <python-command> <skill-root>/scripts/jspace.py note --open "does the parser preserve state?" --settled-by "unit tests over all ledger sections and edge inputs"
  73. <python-command> <skill-root>/scripts/jspace.py note --close 1 --check "the parser preserves state" --by "unit tests over all ledger sections and edge inputs"
  74. <python-command> <skill-root>/scripts/jspace.py seam
  75. <python-command> <skill-root>/scripts/jspace.py ship OUTPUT_FILE
  76. <python-command> <skill-root>/scripts/jspace.py resume
  77. ```
  78. The controller records and reports state. Solution choice remains with the model. It uses the Python standard library and writes working state only under the task's `.jspace/` directory.
  79. ## Generic model integration
  80. An environment with a native Skill loader can install `j-space/` directly. For a chat or API environment, provide [`j-space/SKILL.md`](j-space/SKILL.md) as a system- or developer-level instruction and expose `modules/` and `references/` through file or retrieval tools.
  81. Selected files should be retrieved on demand. Selective loading is part of the operating design.
  82. ## Benchmark
  83. ### 1. Main table
  84. | Benchmark | GLM-5.3-Flash | GLM-5.3-Flash **+ J-Space V3.7**† | GLM-5.3 | Opus-5 | Fable 5.1 |
  85. | ------------------------ | ------------: | -------------------------------: | ------: | -----: | --------: |
  86. | HLE (w/ tools) | 55.3 | 59.2 | 62.5 | 64.7 | 65.0 |
  87. | Terminal Bench 2.1 | 84.3 | 88.8 | 88.2 | *89.1 | *91.4 |
  88. | DeepSWE v1.1 | 63.4 | 68.0 | 66.9 | 68.8 | 67.4 |
  89. | Agents' Last Exam | 26.3 | 30.5 | 28.5 | 31.6 | — |
  90. | AutomationBench (Public) | 48.8 | 51.1 | 48.2 | 50.3 | — |
  91. \* Terminal Bench 2.1 figures for Opus-5 and Fable 5.1 are independently measured by a third party; no official entries exist.
  92. \† Estimated, based on limited controlled experiments.
  93. ### 2. Speed and token efficiency
  94. | Speed | 1.87 |
  95. | -------------------- | :------- |
  96. | **Token efficiency** | **1.41** |
  97. Speed and token efficiency come from a GAIA controlled pair.
  98. ## Cross-model compatibility
  99. The operating effects have been reproduced across the DeepSeek, Qwen, GLM, GPT, and Claude model families. Effect size varies with base capability, context policy, tool harness, sampling configuration, and benchmark implementation.
  100. The portable unit is the protocol: workspace loading, selective routing, state externalization, verification, and recovery. It is independent of a vendor-specific tokenizer or model API.
  101. ## Project structure
  102. ```text
  103. J-Space-Cognition-Suite-V3.7/
  104. ├── .github/workflows/verify.yml # three-platform integrity and regression checks
  105. ├── .gitignore # keeps .jspace/ working state out of the repo
  106. ├── CITATION.cff # machine-readable citation metadata
  107. ├── CONTRIBUTING.md # contribution and provenance requirements
  108. ├── LICENSE # Apache License 2.0
  109. ├── README.md # English engineering guide
  110. ├── README.zh-CN.md # Chinese engineering guide
  111. ├── THIRD_PARTY_NOTICES.md # attribution and license boundaries for source material
  112. ├── tests/test_jspace.py # standard-library controller regression tests
  113. └── j-space/
  114. ├── SKILL.md # single entry, gate, routing, and invariants
  115. ├── modules/ # nine selectively loaded protocols
  116. ├── references/ # evidence, induction, problem modeling, and worked exemplars
  117. └── scripts/
  118. ├── jspace.py # optional loop controller
  119. ├── workspace-ledger.md # ledger template and contract
  120. └── verify_suite.py # authoring-time integrity check
  121. ```
  122. `SKILL.md` is the only registered entry. Modules and references are loaded on demand so the control system does not become its own source of context pressure.
  123. Maintainers can verify the package from its root:
  124. ```text
  125. <python-command> j-space/scripts/verify_suite.py
  126. <python-command> -m unittest discover -s tests -v
  127. ```
  128. ## Technical basis and scope
  129. J-Space uses the operational workspace terminology established by Anthropic's related interpretability research. Within this suite, first-person language is treated as control grammar: accessible state descriptions are bound to explicit actions, checks, and settles.
  130. The suite focuses on observable functional properties—reportability, deliberate maintenance, intermediate computation, broadcast, monitoring, and causal sensitivity. Detailed research interpretation, terminology, evidence boundaries, and sources are maintained in
  131. [`j-space/references/j-space-science.md`](j-space/references/j-space-science.md).
  132. Design principle:
  133. > **Dense on the inside, decodable on demand, clean on the outside.**
  134. Use only the machinery the task earns.
  135. ## Release history
  136. J-Space has progressed through:
  137. **V1 → V1.5 → V1.8 → V2 → V2.5 → V2.6 → V3 → V3.1 → V3.2 → V3.5 → V3.5Turbo → V3.6 → V3.7**
  138. The V3.7 package contains one entry, nine focused modules, four supporting references, an optional runtime controller, an authoring-time verifier, standard-library regression tests, three-platform CI, Apache-2.0 licensing, and machine-readable citation metadata.
  139. V3.7's problem-model routing incorporates the pull request opened by [@lanting200](https://github.com/lanting200), the decline-message fix and ledger-restatement note respond to the issues opened by [@raelldottin](https://github.com/raelldottin) and [@menoxz](https://github.com/menoxz), and the release includes commit contributions from [@afeer123](https://github.com/afeer123).
  140. ## License
  141. J-Space Cognition Suite is released under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). It permits use, modification, redistribution, and commercial integration under its notice and patent terms. See [`LICENSE`](LICENSE) for the complete terms. Quoted or summarized external source material remains subject to its source terms and is identified in [`THIRD_PARTY_NOTICES.md`](THIRD_PARTY_NOTICES.md). When redistributing only the runtime `j-space/` directory, carry both root files with it.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.