[opensourcedex]

J-Space-Cognition-Suite is a free, open source ai development platforms project written in Python and released under Apache-2.0. It has 3,009 GitHub stars, 222 forks and 0 open issues, and was last pushed 4 days ago. On this registry it ranks #126 of 139 tracked projects in AI Development Platforms, with 5 head-to-head comparisons available.

What is J-Space-Cognition-Suite?

J-Space Cognition Suite is a model-agnostic, inference-time control suite for deep reasoning, long-horizon work, verification, and recovery, delivered as one installable skill for a host agent and built for engineers running serious multi-step projects.

What it is

J-Space is an inference-time workspace and control suite for complex reasoning, repository engineering, coordinated agents, and authorized security analysis. It is an agent-skill rather than an application: the project is written in Python and installs into a host such as Claude Code, Codex, OpenCode, a DeepSeek harness, or a Hermes agent. One skill is installed, relevant modules are loaded, and long-task decisions stay connected to durable evidence. Thirteen modules share one premise and one routing entry, and the host continues to supply the tools and the agents that carry out the work. The licence is Apache-2.0.

The concrete problem it solves is the fragility of long agent sessions driven by unmanaged, single-pass prompting, where file maps, intermediate decisions, and evidence live only in the conversation and quietly go stale. Standard-library Python scripts persist state, reread the actual source text, detect stale maps and evidence, and return blocking results when a required condition is missing. A session becomes a checkable trail rather than a stream of suggestions: the controller can refuse to proceed, and the task can be audited or resumed instead of restarted.

Key capabilities

  • Thirteen routed modules behind one entry point, installed as SKILL.md together with modules/, references/, and scripts/.
  • Four operating levels — low, medium, high, and xhigh — with media accepted as an alias for medium; the level sets control depth, from a fast pass with no persistent setup to a loop with bounded agents, second consideration, and independent review.
  • Executable controllers at scripts/control.py and scripts/verify_suite.py, run from the target project's task directory rather than the installed skill directory.
  • The --root TASK_DIRECTORY option points controller work at the target project directory, and status reports on the initialised task.
  • No pip dependencies and no background service; Python 3.10 or later runs the controllers and validation, while low and medium can use the documented prose fallback.
  • UTF-8 input supports English and Chinese task content, deliverables follow the user's requested language, and a Simplified Chinese README ships as README.zh-CN.md.
  • Self-contained distribution: LICENSE and THIRD_PARTY_NOTICES.md are copied alongside the installed SKILL.md.

Who uses it and how

  • Repository engineering teams on multi-file, multi-stage, or persistent work at high, where shared state, source refresh, and evidence checks carry across a long run.
  • Difficult integration work or competing approaches at xhigh, where bounded agents, second consideration, and independent review are used.
  • Authorized security analysis, one of the four stated areas of use.
  • Users of hosts that load skills — Claude Code, Codex, OpenCode, DeepSeek harnesses, Hermes agents; when a host has no agents, the suite records the limitation and does sequential checks.
  • Smaller jobs at low or medium: a direct answer checkable at a glance, or a bounded deliverable with a few dependent steps and a delivery audit.

Getting started

Copy the complete j-space/ directory into the host's Skills directory, keeping SKILL.md, modules/, references/, and scripts/ together and avoiding an extra nested j-space/j-space/, then verify the install with scripts/verify_suite.py on Python 3.10 or later. Installing the files does not register hooks, launch agents, or grant tool access, so the host must be reloaded and the skill selected through its own UI.

How it compares

The facts provide no list of paid products this replaces, so the relevant neighbours are the hosts it plugs into: Claude Code, Codex, OpenCode, DeepSeek harnesses, and Hermes agents. It layers above them rather than replacing any of them, and it defers to each host's own discovery and invocation syntax, supporting $j-space or /j-space only where that host documents it.

When to use it — and when not to

A self-hoster needs a host that can load a local SKILL.md and retrieve its supporting files, plus Python 3.10 or later for the controllers; there is no database, message broker, or background service to operate. It is a poor fit for anyone wanting a standalone service or an out-of-the-box production guarantee, since the suite presents suitability for serious work as a design focus rather than a warranty and notes that installation alone grants no tool access. The registry lists 3,009 stars and 222 forks with no open issues, so prospective users should weigh the community support available to them.

project readme (upstream, from github) — read inline

J-Space Cognition Suite SV1

Simplified Chinese

Concept DOI

J-Space is an inference-time workspace and control suite for complex reasoning, repository engineering, coordinated agents, and authorized security analysis. You install one skill, load relevant modules, and keep long-task decisions connected to durable evidence.

Its thirteen modules share one premise and one routing entry. Standard-library Python scripts persist state, reread actual source text, detect stale maps and evidence, and return blocking results when a required condition is missing. The host supplies tools and agents.

Quick start

You need a host that can load a local SKILL.md and retrieve its supporting files. Python 3.10+ is needed for executable controllers and validation; low/medium can use the documented prose fallback. No pip dependencies or background service are required.

  1. Copy the complete j-space/ directory into your host's Skills directory. Obtain that directory from the host's own configuration; no universal location or invocation syntax applies to every host. Keep SKILL.md, modules/, references/, and scripts/ together; avoid an extra nested j-space/j-space/ directory. Copy LICENSE and THIRD_PARTY_NOTICES.md alongside the installed SKILL.md when distributing the standalone skill. Use an empty destination to avoid mixing installs.

  2. Use Python 3.10 or later to verify the installed directory:

     /scripts/verify_suite.py

  3. Reload the host if it discovers skills only at startup. Select j-space through its skill UI. Use $j-space or /j-space only if that host documents the syntax; otherwise ask it to read the installed SKILL.md explicitly. Confirm it can retrieve one routed module and execute the installed controller's --help if you need strict gates.

  4. Give it the task and its acceptance conditions:

    Use j-space to modify this repository. Inspect the existing contracts, maintain a
source-backed map, delegate independent work where useful, and verify the final behavior.

Replace with your available `python`, `python3`, or `py -3` command. Resolve to the installed directory. Keep the task directory as the working directory, or pass --root TASK_DIRECTORY before a controller subcommand.

For a path with spaces in Bash:

python3 "/path with spaces/j-space/scripts/control.py" --root "/task directory" status

For a quoted interpreter path in PowerShell:

& "C:\Python313\python.exe" "C:\Skills\j-space\scripts\control.py" --root "D:\Task Directory" status

Run status after initializing the task. UTF-8 input supports English and Chinese task content; use the language requested by the user for deliverables. Run controllers in the target project's task directory, not the installed skill directory. Installing the files does not automatically register hooks, launch agents, or grant tool access.

Intended use. This suite is designed for real engineering and production-oriented projects with contracts, dependencies, verification, and recovery needs. It is not aimed at toy demonstrations such as “a pelican riding a bicycle.” Its suitability for serious work is a design focus, not a guarantee that any untested deployment is production-ready.

Operating levels

Level Use Control
low A direct answer checkable at a glance Fast pass; no persistent setup
medium A bounded deliverable with a few dependent steps Full pass; selective modules and delivery audit
high Multi-file, multi-stage, or persistent work Loop; shared state, source refresh, evidence checks
xhigh Difficult integration or competing approaches that benefit from a team Loop plus bounded agents, second consideration, and independent review

media is an accepted alias for medium. Raise the level when the task's uncertainty or dependencies require it. Use agents proactively when independent work justifies coordination. When the host lacks agents, record the limitation and perform sequential checks.

A short tutorial for all four levels

Select the skill first. In commands below, replace and with your installed interpreter and skill directory, quote paths containing spaces, and work in the target task directory. The example artifact names refer to files you create from actual work and checks; do not create empty or fabricated evidence just to pass a gate.

low — a bounded check inside engineering work

Ask: “Use j-space at low to check whether this configuration change preserves the timeout unit. State the conclusion and its evidence; do not expand the task.” Read the relevant input, check the one constraint, and return the result. No state initialization is required. Escalate if the check exposes cross-file dependencies or unresolved uncertainty.

medium — a small deliverable with dependent steps

Ask: “Use j-space at medium to update this API example and verify its parameters against the implementation. Keep a short record of the goal, uncertainty, and observed checks.” Optionally use the lightweight ledger:

<python-command> <skill-root>/scripts/jspace.py note --goal "API example matches implementation" --next "Inspect the endpoint"
<python-command> <skill-root>/scripts/jspace.py note --open "Does the example cover required inputs?" --settled-by "Inspect the endpoint and run the example"
<python-command> <skill-root>/scripts/jspace.py seam

Inspect and run the example, then record the actual outcome with note --check "Observed result" --by "manual inspection of each input and execution of the reported case" --close 1. Write answer.md, then run jspace.py ship answer.md. This audits text heuristically; findings are advisory, while unreadable/oversized input is rejected. It does not prove the API behavior. Do not maintain this ledger alongside the strict controller for the same task.

high — repository work from inspection to delivery

Ask: “Use j-space at high to repair this repository issue. Preserve public contracts, keep a source-backed map, run the relevant tests, and finish with evidence against each requirement.” Follow the Shared control section to initialize, read sources, create/sync/view the map, and pass the work gate. Perform the work; record real verification in evidence/root.txt and a separate acceptance checklist in evidence/completion.txt. Keep src/router.py below only if it is a material source dependency; substitute your actual sources and repeat --source as needed.

<python-command> <skill-root>/scripts/control.py pulse --event checkpoint
<python-command> <skill-root>/scripts/control.py report --agent root --round 1 --summary "Observed repair and coverage" --evidence evidence/root.txt --completion evidence/completion.txt --source src/router.py --next "Deliver checked result"
<python-command> <skill-root>/scripts/control.py repo sync --map repo-map.json
<python-command> <skill-root>/scripts/control.py repo view --agent root
<python-command> <skill-root>/scripts/control.py repo check
<python-command> <skill-root>/scripts/control.py check --stage ship

Update the map's meaning before that final sync. Creating report/checklist files changes the inventory too. Resolve open questions and security candidates before shipment. Exit 0 allows delivery; a nonzero result names an unmet condition. Repair that condition before checking again; identical retries without changed evidence are not recovery.

xhigh — actual independent work and integration

Ask: “Use j-space at xhigh for this integration. Assign an independent contract review to a real child agent, request its second consideration, reproduce material findings, and retain disagreements until a discriminating check resolves them.” From an initialized high task, route before creating reports for the current scope:

<python-command> <skill-root>/scripts/control.py route --level xhigh --module modules/repository.md --reason "Independent integration review"
<python-command> <skill-root>/scripts/control.py read --agent root
<python-command> <skill-root>/scripts/control.py agent add --id reviewer --parent root --task "Inspect the integration contract" --owns src
<python-command> <skill-root>/scripts/control.py pulse --event resume --agent reviewer
<python-command> <skill-root>/scripts/control.py repo view --agent reviewer
<python-command> <skill-root>/scripts/control.py check --stage work --agent reviewer

The host must actually launch that child and deliver its own pulse output; an ID is not an independent model. The child writes distinct evidence/review-1.txt and evidence/review-2.txt after two substantive passes, then submits each

readme truncated — read the full docs on github

Frequently asked questions

Is J-Space-Cognition-Suite free to use?

J-Space-Cognition-Suite is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does J-Space-Cognition-Suite do?

J-Space Cognition Suite — a model-agnostic inference-time control suite for deep reasoning, long-horizon work, verification, and recovery. Based on Anthropic's

What is J-Space-Cognition-Suite written in?

J-Space-Cognition-Suite is primarily written in Python. Its source is publicly available at https://github.com/Tiger3807861189/J-Space-Cognition-Suite, and it has 3,009 GitHub stars.