RapidKit
UnderstandChangeEvidenceGateGroundDistributeExplain

Workspace Intelligencefor Software Systems

Create new software or connect the projects you already have. Workspai turns them into one evidence-backed workspace shared by developers, CI, IDEs, and AI agents.

Get StartedGitHub
npm install -g workspai

Recommended quick start · Full CLI reference

52
Core Modules
23
Create Targets
100%
Open Source
Features

From scattered projects to shared understanding

Start new projects, adopt existing software, and keep the model, graph, Doctor findings, verification evidence, and agent context synchronized.

Workspace Intelligence

A canonical model, derived knowledge graph, Doctor findings, and verification evidence describe the same workspace.

Polyglot Kits

Create backend, frontend, desktop, and extension projects through native or official generators — or adopt existing software in place.

Module Catalog

52 Core modules install with dependency resolution, snippet injection, and router mounting — not copy-paste boilerplate.

Agent-Ready Context

Generated grounding directs agents to bounded model, graph, and evidence queries instead of making them rediscover the repository.

Change Governance

Diff from git, assess impact, run strict verify, and trace evidence before you merge or hand off.

Own Everything

Generated code and portable workspace evidence stay under your control, with open JSON contracts for every consumer.

Choose a Surface

Start where your work already happens

Use the Workspai CLI for workspace operations, RapidKit Core for Python-backed kits and modules, or the VS Code extension for a visual workflow. All three surfaces meet at the same workspace contract.

Example:
Terminal
$npm install -g workspai
$workspai create project nextjs web
Existing project → shared evidence
$cd /path/to/project && workspai adopt .
$workspai workspace intelligence run --for-agent generic --strict --json
$workspai create project nextjs web
Install via NPM
Product Portfolio

Explore the Chistiq portfolio

RapidKit Core, Workspai CLI, and Workspai for VS Code are separate surfaces over one workspace intelligence foundation.

52 metadata-backed modules

Modular by Design

Core-backed modules for FastAPI and NestJS — auth, database, cache, observability, and more. Install with one command inside a governed workspace.

Settings

Configurable application settings module with FastAPI and NestJS adapters.

Middleware

HTTP middleware pipeline with FastAPI and NestJS support.

Logging

Structured logging infrastructure with FastAPI and NestJS integrations.

Deployment

Deployment tooling for RapidKit services.

52 free modules synced from Core·View live catalog →
Explore all modules
Interactive Demo

See Workspai in Action

Watch the contract-backed loop run understand → change → evidence → gate → ground → distribute → explain: refresh context, sync agent surfaces, and govern supported or imported runtimes from the same workspace model.

workspai — interactive demo
See it in action

Contract-first, runtime-aware

Workspai turns repositories, projects, dependencies, rules, changes, and evidence into shared understanding for developers, CI, IDEs, and AI agents. The same contract grounds services, modules, commands, delivery evidence, and generated docs.

{
  "schemaVersion": 1,
  "kind": "rapidkit.workspace.contract",
  "generatedAt": "2026-07-27T00:00:00.000Z",
  "workspace": { "name": "commerce-platform", "profile": "polyglot" },
  "projects": [
    {
      "slug": "api",
      "relativePath": "services/api",
      "source": "workspace",
      "runtime": "python",
      "framework": "fastapi",
      "kit": "fastapi.standard",
      "modules": [],
      "ports": [{ "name": "http", "port": 8000, "protocol": "http" }],
      "contracts": {
        "owns": ["users"],
        "apis": [{ "name": "users", "basePath": "/users" }],
        "publishes": [],
        "consumes": [],
        "dependsOn": [],
        "env": ["DATABASE_URL"]
      }
    }
  ]
}
Why RapidKit

One workspace truth. Full ownership.

Unlike framework-only starters or scattered boilerplates, RapidKit combines polyglot kits, installable modules, and contract-backed workspace intelligence for developers, ci, ides-and-extensions, ai-agents — all committed to your repository alongside the code you ship.

Workspace truth
Knowledge split across files and tools
Canonical model + derived, evidence-bound graph
Polyglot scope
Separate setup path for each stack
Native + official create targets + adopt
Module catalog
Package selection and wiring tracked separately
52 metadata-backed Core modules
AI agent alignment
Each agent rediscovers project context
Generated grounding + bounded evidence queries
Change governance
Checks run without a shared evidence chain
diff → impact → verify → trace
IDE + CLI parity
Each surface maintains its own state
Shared contracts across CLI and extension
Project entry
Separate setup and registration flows
Create, adopt, or import through one planner
Code ownership
Source without a shared workspace model
Source + portable evidence under your control

Govern the workspace, not just the repo

Polyglot creation, metadata-backed modules, and workspace intelligence — all in your git. No SaaS lock-in.

Agent-readyOpen contractsCreate or adopt
Workspace CLI

Create, adopt, and understand your software workspace

Start a new workspace or enter an existing project and adopt it in place. Workspai detects the runtime and keeps project context, the canonical model, knowledge graph, Doctor findings, and verification evidence synchronized. 101 documented commands remain available when you need a deeper workflow.

$npm install -g workspai
🚀Start
$ workspai my-workspace$ workspai adopt .$ workspai create project nextjs$ workspai create project tauri
🧠Intelligence
$ workspai workspace model$ workspai workspace context$ workspai workspace verify$ workspai workspace diff
🛡️Governance
$ workspai workspace impact$ workspai workspace trace$ workspai workspace explain$ workspai doctor
🧩Modules & Dev
$ workspai add module auth$ workspai modules list$ workspai dev$ workspai build

View complete CLI reference → · 101+ documented npm surface commands with ownership labels

Release evidence

Shipped surfaces, not slogans

Trust signals from Core module metadata, the kit registry, workspace intelligence artifacts, CLI ownership rules, and Workspai parity — synced to what actually ships.

Contract-backed

52 Core modules

Module registry

The public catalog is generated from Core module metadata — every module page reflects shipped install artifacts, not hand-written marketing copy.

Contract-backed

23 available create targets

Kit registry

Backend, frontend, desktop, and extension targets share one planner while preserving native and official generator ownership.

Contract-backed

Model · context · verify

Workspace intelligence

CLI commands materialize workspace topology, agent context, diff/impact evidence, and strict verify reports under `.workspai/reports/` in your repo.

Contract-backed

Bridge-safe commands

CLI ownership matrix

The npm CLI owns polyglot scaffolding and intelligence while Python Core remains the source of truth for the 52-module catalog and generation gates.

Contract-backed

IDE + CLI alignment

Workspai parity

The VS Code extension reads the same contract, archive, doctor, and verify evidence the CLI writes — no duplicate truth or stale sidebar state.

Contract-backed

Stabilization evidence

Release gates

Shared stabilization gates exercise module installs across supported kits and runtimes without dropping per-module release evidence.

Portable by design — workspace evidence travels with your software

Vercel
AWS
Railway
Render
DigitalOcean
Fly.io
Docker
Kubernetes

Portable workspace contracts and evidence — deploy generated or adopted software on the platform your team already uses

Bring your software into one shared workspace

Start from scratch or adopt an existing project in place. Workspai builds the evidence developers and agents need to understand the system before changing it.

$npm install -g workspai
Get Started GitHub