SPEC//OS

See a project before you connect

Explore a small project below, then keep coding in Codex, Claude Code or Cursor. Connect SPEC//OS once and give your agent the project brief from the home page. The agent reads the context, manages specifications and records evidence here while it writes and tests code in its own environment.

A project you can explore now

Taskboard — public example

Illustrative · read only

This example shows the structure of a project. It is not a saved project, an applied specification or a test result. Viewing it needs no account and starts no AI operation.

INTENT

Let a person complete a task, keep that change after a reload, and keep each account's tasks separate.

Context and Constitution

Illustrative TypeScript web application

A task list with account-scoped persistence; no repository is connected.

EXAMPLE-RULE-001 · MUST Preserve saved tasks when changing their completion state.

EXAMPLE SPECIFICATION

Keep task completion reliable and account data separate.

EXAMPLE-REQ-001Keep completed tasks after a reload

Proposed in this example · Not evaluated

EXAMPLE-AC-001.1

An identified reviewer confirms that completing a task and reloading preserves its completion state.

Verification method: identified human review

EXAMPLE-REQ-002Keep each account's tasks separate

Proposed in this example · Not evaluated

Depends on EXAMPLE-REQ-001

EXAMPLE-AC-002.1

An identified reviewer confirms that completing a task in one account leaves another account's tasks unchanged.

Verification method: identified human review

Evidence: none · Not evaluated

Illustrative content only. No checks have been run and no evidence is attached.

What would happen next

Review task completion after a reload

EXAMPLE-REQ-001EXAMPLE-AC-001.1

This example has no recorded review for EXAMPLE-AC-001.1.

Inspect the example JSON
{
  "schemaVersion": "specos.public-example/1",
  "illustrative": true,
  "readOnly": true,
  "persisted": false,
  "project": {
    "id": "EXAMPLE-TASKBOARD",
    "name": "Taskboard — public example",
    "intent": "Let a person complete a task, keep that change after a reload, and keep each account's tasks separate.",
    "context": {
      "stack": "Illustrative TypeScript web application",
      "architecture": "A task list with account-scoped persistence; no repository is connected.",
      "constraints": [
        "Preserve existing tasks",
        "Keep account data separate"
      ]
    },
    "constitution": [
      {
        "id": "EXAMPLE-RULE-001",
        "kind": "MUST",
        "text": "Preserve saved tasks when changing their completion state."
      }
    ]
  },
  "appliedSnapshot": null,
  "serverRevision": null,
  "spec": {
    "objective": "Keep task completion reliable and account data separate.",
    "requirements": [
      {
        "id": "EXAMPLE-REQ-001",
        "title": "Keep completed tasks after a reload",
        "source": "proposed",
        "dependencies": [],
        "criteria": [
          {
            "id": "EXAMPLE-AC-001.1",
            "statement": "An identified reviewer confirms that completing a task and reloading preserves its completion state.",
            "verifierId": "human_review"
          }
        ]
      },
      {
        "id": "EXAMPLE-REQ-002",
        "title": "Keep each account's tasks separate",
        "source": "proposed",
        "dependencies": [
          "EXAMPLE-REQ-001"
        ],
        "criteria": [
          {
            "id": "EXAMPLE-AC-002.1",
            "statement": "An identified reviewer confirms that completing a task in one account leaves another account's tasks unchanged.",
            "verifierId": "human_review"
          }
        ]
      }
    ]
  },
  "evidence": [],
  "verification": {
    "status": "NOT_EVALUATED",
    "reason": "Illustrative content only. No checks have been run and no evidence is attached."
  },
  "nextWork": [
    {
      "requirementId": "EXAMPLE-REQ-001",
      "criterionId": "EXAMPLE-AC-001.1",
      "title": "Review task completion after a reload",
      "reason": "This example has no recorded review for EXAMPLE-AC-001.1."
    }
  ]
}

Costs before you start

Compilation, chat and agent generation can consume credits. Their current credit cost depends on the selected company workspace and its configuration. Sign in and select that workspace to review the configured cost before approving a paid request.

There is no universal public credit price. Personal provider costs and monetary costs, including a USD conversion, are unavailable here. An unknown cost does not mean zero. Your coding agent or provider may charge separately.

The live catalogue marks audited MCP operations that consume no SPEC//OS credits with a credit cost of zero. Paid or unpriced operations report an unknown cost until the relevant scope can be checked. Reading this page or the illustrative example starts no paid request.

Start or continue

For a new project, save your idea on the home page. For an existing one, provide the GitHub repository and the next change. Open a recent project to recover its agent brief at any time.

Your agent uses its own authorized GitHub connection to create or clone repositories and prepare changes. The SPEC//OS GitHub App separately provides read access to the repositories you authorize. Adding a repository URL does not grant that access.

Choose a project

Endpoint

/mcp

Streamable HTTP with OAuth 2.1. The first connection opens a sign-in and consent page in your browser.

Is your assistant showing the old list?

Assistants store the tool list on their side, at the moment the connector is created. Opening a new chat does not refresh it — the stale list follows your account into every new conversation.

This address answers without any sign-in and lists exactly what this server exposes right now:

/api/public/mcp-tools

If the number there is higher than what your assistant shows, the assistant is the one out of date. Two ways to fix it, both requiring your sign-in:

  • In Claude or ChatGPT: Settings → Connectors, remove SPEC//OS, then add it again with the endpoint above.
  • In Claude Code, register the server in a terminal of yours, then run /mcp inside an interactive session to authenticate:
    claude mcp add --transport http --scope user specos /mcp

After reconnecting, open a fresh conversation and ask for the tool list — a session keeps the list it received when it started.

Claude Code, step by step

  1. Run this in a terminal on your computer:
    claude mcp add --transport http --scope user specos /mcp
    It only registers the address — no token is typed here.
  2. Start Claude Code and run /mcp, then choose specos and authenticate. Your browser opens the SPEC//OS sign-in and a consent screen listing what the assistant may do.
  3. Approve it. The browser hands the authorization back to Claude Code, which stores the token for you.
  4. Run /mcp again to confirm. The list looks like this:
      specos   ✔ connected   http (user)
        tools: list_projects, project_state, compile_specification,
               apply_revision, add_evidence
  5. Ask something like “list my SPEC//OS projects”. If it answers with your projects, the connection works.

If it shows “needs authentication”, run /mcp and authenticate again — the token lives on your computer and expires.

Claude

Settings → Connectors → Add custom connector, name it SPEC//OS and paste the endpoint. Claude opens the sign-in and consent page; after approving, the tools appear in the attachments menu of a conversation.

/mcp

ChatGPT

Settings → Connectors → Advanced → Developer mode, then Add custom connector and paste the endpoint. Approve the sign-in, then enable SPEC//OS in the composer for the chats that should use it.

/mcp

Cursor and Codex

Add a remote MCP server (streamable HTTP) with this URL and complete the sign-in when the client opens it.

/mcp

Project and repository tools

project_workflow

Read

Returns the supported next steps for starting or continuing a project, including the work performed by your external coding agent.

Needs
Mode, explicit workspace and the existing project for continue.
Returns
Capabilities, steps, project context and honest connection requirements.

project_context

Read

Reads the complete current intake, constitution and applied snapshot before coding.

Needs
Exact project and explicit workspace.
Returns
Context, constraints, current revision, unapplied changes and verification status.

create_project / set_project_context

Writes data

Creates a project in an explicit workspace, or saves reviewed repository context to an existing project.

Needs
Name and intent for creation; current expected revision for a context update.
Returns
Server-confirmed project identity or saved revision.

github_connection

Read

Lists the GitHub App installation, authorized repositories and project bindings for a company.

Needs
Explicit workspace.
Returns
Configuration and current authorized repositories; no tokens.

bind_project_repository

Writes data

Associates a project with a repository from the authorized installation. Requires the appropriate company role.

Needs
Project, workspace and repository identity returned by the connection tool.
Returns
Confirmed repository binding.

inspect_project_repository

Read

Uses the bounded repository reader to inspect the bound repository and propose project context.

Needs
Exact project, workspace and requested ref.
Returns
Repository analysis and proposed intake for review; existing context is not overwritten.

Specification and evidence tools

Reading is immediate. Anything that writes or spends credit is stated below so the assistant can ask you first.

list_projects

Read

Lists every SPEC//OS project you can reach, in your own account and in the companies you belong to, most recently active first. The usual first call, to find the project to work on.

Needs
Optionally the company, when the same project name exists in more than one. Without it, an ambiguous name is refused rather than guessed.
Returns
Project identifier and name, the company it belongs to, current synchronization revision, last activity and applied specification size. Synchronization and specification revisions are separate.

project_state

Read

A compact status summary for one project. Use project_context for the full intake and applied specification.

Needs
The project (identifier or name from list_projects), and optionally the company.
Returns
Intent, revision, requirement and criterion counts, implementation status and excluded evidence. Separate read tools expose the specification, evidence and history.

compile_specification

Spends credit

Turns the current intent into a proposed specification, grounded in the project context and its decisions. It changes nothing on its own — the result is a draft for you to read. Quota, write permission and usage are checked before any cost, and repeating the same request does not charge twice.

Needs
The project, and optionally the company. The intent must already be written.
Returns
A draft specification: requirements, acceptance criteria, open questions and conflicts, marked as not applied, together with a proposal token that ties the draft to the project, company, revision and inputs that produced it.

apply_revision

Writes data

Applies a draft as the project's next revision. The proposal token is required: if the intent, context, constitution or applied revision changed after the draft was produced, the request is refused instead of overwriting newer work, and the same token cannot be applied twice. The previous revision stays in history.

Needs
The project, the draft specification, the proposal token returned by compile_specification, and a short reason for the change.
Returns
Confirmation with the new revision number and the reason recorded in history.

add_evidence

Writes data

Records the result of a check you actually ran. The exact applied snapshot id is required; a newer revision is refused even if the capture time is recent. Quantitative checks require the observed value and matching unit. Recording evidence does not itself mean a criterion passed.

Needs
Project and workspace, snapshot_id from project_context, requirement, criterion, verifier_id and SPEC//OS verifier_version (currently 1), real source/runner version, artifact, sample, capture time, origin, decision, reviewer, commit and confidence. Include value, unit and measured conditions for quantitative criteria; human review requires an identified reviewer and decision.
Returns
Confirmation with the snapshot, evidence id and synchronization revision. Call show_verification to read the evaluated result.

Suggested flow

  1. Read the project state before answering anything about it.
  2. Write or refine the intent.
  3. Compile, review the draft, then apply it as a new revision.
  4. Run the tests and attach the evidence, criterion by criterion.

What the assistant can and cannot do

  • It acts as you: same account, same companies, same projects, same permissions.
  • It never sees your password, and it cannot read other people's accounts.
  • Compiling a specification is a paid MCP operation. Configured chat and generation operations also consume SPEC//OS credits. Your external agent's own usage is billed by its provider.
  • You can revoke access at any time by removing the connector in the assistant, and the history of everything it did stays in the project.