Prism: One spec. Every platform.

Prism is a shared workflow and board for humans and agents. Product knowledge, questions, evidence, and delivery state live in the repository's wiki. Application template generation is an optional way to start a workspace.

It helps product and engineering teams:

• carry a feature from business requirement through specification, design, implementation, QA and release to operation, with bound evidence and an accountable role at every stage
• connect coding agents through standard MCP and the same versioned Prism skills
• keep approval with people: agents propose, and a human who holds the role of the stage approves in the board
• optionally generate backend, web, Android, iOS, and AI agent service foundations

This repository contains Prism's CLI, workflow service, board, and application template. It is the maintainer repository, not a workspace for running product lifecycle actions.

Follow the quickstart to adopt the workflow in an existing repository or an empty workspace. The shared board guide has the details, and current status records what is verified and what is open.

Prism runs on one computer. One local service per workspace serves the browser board and an MCP endpoint, so you and your coding agents work on the same wiki. Prism needs Python 3.10 or later; uv installs one when none is present. Install it from PyPI as prism-kit, which provides the prism command:

uv tool install prism-kit
prism --version

pipx install prism-kit and pip install prism-kit work as well. If prism is not found after uv tool install, run uv tool update-shell and open a new terminal. To upgrade later, run uv tool upgrade prism-kit.

Without a Python setup. With Node.js 22 or later, the npm launcher runs the same CLI; it fetches uv and the matching prism-kit on first use:

npx @mortitech/prism --version

npm install --global @mortitech/prism installs it as the prism command. The rest of this page writes prism <command>.

From source (contributors). Clone the repository and install it in editable mode:

git clone https://github.com/mo0rti/prism.git
cd prism
pip install -e .

Run the remaining steps in a separate workspace folder, not in this maintainer checkout and not in a cloud-synced folder such as OneDrive.

1. Add the workflow. Use an empty folder or an existing repository. Choose a display name and, if you want, an app: --app takes one of the generated app IDs (backend, web, mobile-android, mobile-ios, agent-service) and registers it without generating an application. Without --app the workspace has no apps, and prism app add registers one later (the workspace model covers apps, repositories and prism app list). The first command previews every file. The second asks you to confirm before it writes (--apply --yes skips the question for automation).

cd path/to/your-workspace
prism workflow install . --name "My workspace" --app backend
prism workflow install . --name "My workspace" --app backend --apply

For one wiki shared by apps that live in other repositories, use --knowledge-root instead of --app (knowledge root over several repositories).

2. Check readiness. The "Shared board" section lists what needs attention, each with a Fix: line. A warning that no grant exists yet is expected at this point.

prism doctor --workspace .

3. Register a person and an agent. Each command prints JSON whose token appears once. Keep tokens private and out of files and prompts. A grant without --write is read-only. A writable human grant holds the workflow roles po, designer, tech-lead, dev, qa and release that the person may approve (--role, comma-separated); a team of one holds all six. An agent grant holds no role: the agent proposes, and a human approves in the board.

prism board grant "Riley" --kind human --write --role po,designer,tech-lead,dev,qa,release --path .
prism board grant "Coding agent" --kind agent --write --path .

Put the agent's token in an environment variable before you start the agent host:

export PRISM_BOARD_TOKEN="<the agent's token>"      # macOS, Linux, Git Bash
$env:PRISM_BOARD_TOKEN = "<the agent's token>"      # PowerShell

4. Start the board.

prism board serve . --port 8765

It prints the board URL, the MCP endpoint (http://127.0.0.1:8765/mcp) and a hint for issuing another grant, then opens your browser (--no-open skips that). Sign in with the human token. Press Ctrl+C to stop. The service listens on loopback only.

5. Connect Claude Code and Codex. Both use their standard Streamable HTTP MCP configuration with that endpoint and PRISM_BOARD_TOKEN. The exact entries are in Connect an agent host. Give each host its own grant, and start the host from a shell where the variable is set. Agent hosts lists the tested versions, settings and known limitations.

6. Run a first journey.

1. Ask the agent to run Prism's setup-project skill. Setup is an interview that writes the product context directly into the workspace, so it does not go through the board.
2. Create a folder named with today's date and a short slug, such as knowledge/intake/pending/2026-10-06-my-first-feature/, and put your brief in it as a Markdown file, using knowledge/intake/pending/PO_BRIEF_TEMPLATE.md as a guide. Then ask the agent: "Use Prism's PO intake skill to refine the pending brief." The agent shows the exact file changes, you confirm them in the agent, and it applies them. A new feature appears on the board as raw. Notes that are not a feature request, such as research, a plan, a bug report, an incident or a roadmap statement, go through the ingest skill the same way; knowledge/wiki/index.md lists every page and knowledge/wiki/status-board.md is the status board of the features, the bugs and the apps in operation.
3. Ask the agent to run po-specify on the feature. A change that advances a status is gated: the agent proposes it, and it waits under Proposals in the board header. Open it, review the evidence and the exact changes, tick "I reviewed this change and approve it." and choose Approve and apply. The grant that approves must hold the role of the action (po here); the agent cannot apply it.
4. In the board, move the feature with po-handoff (drag its card or use its action control). The board offers the same human action for design-start and dev-start. Design (tech-design-done, design-ui-done, design-handoff), delivery (dev-done), QA (qa-verify, qa-pass) and release (release-done) run the way po-specify does: the agent proposes, and the person with the role approves under Proposals. A released feature has a release record in knowledge/wiki/releases/.

If a step fails, docs/troubleshooting.md lists the symptom, cause and fix for the common cases. The shared board guide covers every command, the MCP tools and recovery of interrupted operations, and SECURITY.md describes what the local service protects.

Graph view from the synthetic local TreasuryFlow fixture.

To explore a populated example first, follow the local wiki visualization guide. It builds a synthetic TreasuryFlow fixture that is safe to regenerate.

Application generation is separate from the shared board. Run prism for the home screen, or prism new for the guided flow.

A Prism-generated repository can include:

• Backend: Spring Boot 4, Kotlin 2.2+, Java 21
• Web app (one or more, one per audience): Next.js + TypeScript with a local development sign-in and one authenticated read
• Android app (one or more): Kotlin + Jetpack Compose with a local development sign-in and one authenticated read
• iOS app (one or more): Swift + SwiftUI with a local development sign-in and one authenticated read
• Agent service (one or more): Python + FastAPI that assists and never advises, with a provider interface (a deterministic fake and a Claude adapter), one read-only tool that reads the backend with the user's own token, bearer-token verification against the backend's dev-identity key, and an evaluation harness

Every generated repository also includes:

• a living product wiki under knowledge/wiki/
• generated AI context for Claude, Codex, and Cursor
• lifecycle commands for PO, design, dev, QA, release, bugs, and advisory review
• project docs and workflow wiring

From the Prism home screen:

• choose Doctor to check prerequisites
• choose New Project to generate a sample repo
• choose Browse Presets if you want to browse the recommended starting paths first

After generating a project:

1. open the generated repository
2. inspect README.md, AGENTS.md, knowledge/wiki/SCHEMA.md, knowledge/wiki/LIFECYCLE.md and knowledge/wiki/ACTIONS.md
3. initialize the workflow with:
   • Claude Code: /setup-project
   • Codex: $setup-project
   • Cursor: ask the agent to run setup-project
4. register participants and start the board as in the quickstart above (prism board grant, then prism board serve .). prism new already pins the workspace to the workflow, so the board accepts writes without prism workflow upgrade; that command is needed only after a newer Prism ships a new workflow.

For the full first-run path, read docs/getting-started.md.

Read the shared board guide, then the wiki workflow. The local service shares one workspace between the browser and standard MCP clients. The workspace model explains how a workspace declares its apps and repositories.

Read these first:

1. docs/getting-started.md
2. docs/questionnaire.md
3. docs/generated-projects.md

Read these first:

1. README.md inside the generated repository
2. AGENTS.md inside the generated repository
3. docs/generated-projects.md
4. docs/wiki-workflow.md

Read these in order:

1. docs/prism-model.md
2. docs/wiki-workflow.md
3. docs/ai-surfaces.md

Start with:

1. docs/maintainer-workflow.md
2. docs/current-status.md
3. docs/README.md

• The workflow, the shared board, the MCP tool contract and the human board actions are implemented and tested; the plan states their scope and contracts.
• The lifecycle from intake through design, QA and release to operation is implemented in the shared service and covered by regression tests: roles on grants, gated approval in the board, design tracks, the QA stage, bugs, release records, incidents and runbooks. With a real agent host (Codex), the journey covers intake through design clarification, including a gated approval in the browser (current status).
• Prism 0.7.0 is released: prism-kit on PyPI and the GitHub release with checksums.
• Application packs: the backend, Android, web and agent-service packs are verified locally and in CI, and the iOS pack is built and tested only by the macOS CI job. Generated workspaces ship no deployment: the deployment skill holds unverified worked examples for Azure Container Apps and Cloudflare.
• Core acceptance uses disposable neutral workspaces. Sample behavior does not define the core workflow.
• Prism is released under the MIT license and published to PyPI as prism-kit, with the @mortitech/prism launcher on npm. The changelog lists what each version contains.

For the detailed status, read docs/current-status.md.

For the full documentation index, read docs/README.md.

• AGENTS.md for Codex maintainer guidance in this repo
• CLAUDE.md for Claude maintainer guidance in this repo

Prism is released under the MIT license, copyright 2026 Mortitech. The vendored force-graph library keeps its own MIT license; see third-party notices.