Start with MCP

Verify another agent's output, sign an audit record, preserve an agreement transcript, or verify text and images. Start with the use cases to choose the appropriate MCP profile, then connect your client.

JACS signs structured data and verifies it using explicit public evidence. MCP is the primary integration. Install the portable CLI and start its stdio server:

cargo install jacs-cli --locked
jacs mcp

The default profile exposes jacs_verify_document. Verification checks integrity under the supplied public key; identity, consent, trust and permission remain application decisions. Diagnostics go to stderr and stdout carries only MCP.

Explicit local signing provides create, sign, verify, rotate, re-encrypt and encrypted import/export operations for one selected vault. New identities use pq2025 (ML-DSA-87), without automatic classical fallback. Passwords belong in the host's prompt or designated environment variable, never in MCP parameters.

See the complete MCP contract and configuration guide and CLI commands. The extended MCP profiles provide separate agreement and media capabilities for existing integrations.

Rust, Node.js, Python and Go remain supported direct libraries, alongside browser and mobile bindings. See supported packages or choose your language in the navigation. Native APIs include capabilities beyond the portable MCP tool set; they remain in their own dependency workspace.

JACS use cases

Start with MCP when an agent or tool host needs local signing and verification. Rust, Node.js, Python, Go, browser and mobile libraries remain available for embedding the same primitives in an application. Choose the integration by its actual capabilities and the authority the host is prepared to grant.

Verify an artifact before using it

Use the default jacs mcp server to check signed JSON received from another agent, tool or service. It needs no signing identity or private key.

1. The host selects the expected signer's public key and algorithm from its trusted state, independently of the received document.
2. Call jacs_verify_document with the signed JSON and that public evidence.
3. Parse the JSON text in the MCP result and require valid: true. A successful JSON-RPC response alone is insufficient.
4. Apply the application's identity, freshness, revocation and authorization policy before acting on the verified content.

This is useful for agent handoffs, signed tool outputs, stored memories, configuration and audit records. It verifies integrity under the chosen key; the application decides whether to trust and use the result.

Sign agent output with one selected identity

Use portable local-sign to sign JSON before it leaves an agent or service. The host selects one encrypted vault and supplies its password outside the tool request. The process can create, sign, verify, rotate, re-encrypt and import/export encrypted material within that vault.

The grant applies to the process. Applications that need human approval for each signature must enforce it in their own host flow. New identities use pq2025 (ML-DSA-87), and an error never triggers an algorithm downgrade.

See the MCP configuration guide and portable tool contract.

Record agreements and review text or images

The separate jacs-compat mcp server's extended local-sign profile provides document signing and Agreement v2 operations. An explicit content directory also enables text/image signing, verification and signature extraction.

Use these for signed agreement transcripts, reviewed documents and media provenance. The host selects the agent and content directory; a tool cannot choose arbitrary key storage or filesystem roots. The exact 1/9/14-tool profiles are documented in the extended MCP guide.

Embed JACS in a service or application

Direct libraries retain capabilities beyond the portable MCP tool set:

The compiled native MCP inventory has 42 names. Only the selected runtime profile's authorized subset is callable; installing a library does not expose all of its APIs as MCP tools. See the example index for retained examples and their validation limits.

Connect an MCP client

Install the portable CLI:

cargo install jacs-cli --locked
jacs mcp

For clients that accept an mcpServers configuration, the verification-only connection is:

{
  "mcpServers": {
    "jacs": { "command": "jacs", "args": ["mcp"] }
  }
}

The host starts a local stdio process. There is no HTTP listener; diagnostics go to stderr. The only default tool is jacs_verify_document. Select the signer's public evidence independently, parse the returned JSON text, and check its valid field. See the verification use case.

Enable local signing explicitly

Create an encrypted agent in a private directory from a terminal:

mkdir -m 700 .jacs
jacs create --output .jacs/agent.json > public-identity.json
jacs mcp --profile local-sign --agent .jacs/agent.json

The terminal prompts for the password. A noninteractive MCP host must supply JACS_PRIVATE_KEY_PASSWORD through its secret-handling mechanism; do not put passwords in tool arguments, command arguments or committed client config. Use an absolute vault path in the client's process configuration.

Local signing enables all seven portable tools for the selected vault. Rotation and re-encryption additionally need the destination password at startup through JACS_NEW_PRIVATE_KEY_PASSWORD. The host owns approval of that process-level grant. Unix vault permissions are enforced; platforms without the required filesystem custody adapter can still verify public data.

For agreements and text/images, choose the separate extended MCP profiles. For service integration, use the direct libraries.

Extended CLI and MCP profiles

The primary entry point is jacs mcp, from cargo install jacs-cli. Both JACS command-line programs are written in Rust. The focused jacs binary provides portable signing, verification, encrypted keys and MCP. The extended jacs-compat binary provides the broader integration commands, including agreements, A2A, text/media, attestations and trust operations:

cargo install jacs-cli-compat --locked
jacs-compat mcp

The 0.15 package split isolates the portable dependency graph from the broader integration dependencies. It does not make either program a different language, and it does not deprecate the direct libraries. Email signing is available through the Rust library; there is no dedicated email CLI command.

From this checkout, make build-jacs-compat builds that binary and make mcp-compat starts it without writing Make output to protocol stdout. It uses the separate archive/native workspace; the portable dependency graph is unchanged.

The extended CLI compiles the full tool families, but runtime authorization restricts the advertised and callable subset. To select an existing local agent:

jacs-compat mcp --profile local-sign --config /path/to/jacs.config.json

For local text/image signing, verification and extraction:

JACS_MCP_BASE_DIR=/path/to/content \
  jacs-compat mcp --profile local-sign --config /path/to/jacs.config.json

Use the existing password prompt or designated password environment variable. Keep network capability flags unset. File arguments are relative to the selected content directory; config and key directories cannot be used as content roots. The selected process can sign as this agent; it does not provide per-call human approval. Ordinary HAI photo policy remains an application decision.

The 42-name native contract is a compiled inventory. A2A, attestation, trust administration, W3C signing and key administration are not all enabled by local-sign. trust-admin and legacy-core still refuse startup because the capability/status/approval broker they require is absent. Preparing a broader profile means implementing that authority boundary and testing advertisement, dispatch, revocation and expiry together. Adding names to an allowlist would bypass that requirement.

See the extended MCP protocol and authorization details. make test-jacs-mcp-compat exercises the native profiles and contract with full-tools; make test-jacs-mcp tests the portable server.

Supported libraries and packages

MCP is the recommended starting point for agent/tool integration. Direct libraries are supported integrations too. The native workspace's location at archive/native keeps its dependencies separate from the portable core; it does not deprecate the native Rust, Node.js, Python or Go packages.

JACS 0.15.0 is published across all 17 Rust crates, native npm, browser npm, PyPI and Go. See the release inventory for platform coverage, verified artifacts and provenance.

jacs-media and jacs-binding-core remain the shared native media/binding layers. jacs-mcp and jacs-mcp-compat are distinct server libraries. The published jacsnpm, jacspy and jacsgo Rust crates implement their language boundaries; application users normally install their npm/PyPI/Go packages.

Choose by capability

The portable core, browser and mobile libraries cover cryptography and encrypted identity lifecycle. They do not include native filesystem, email, database or network integrations. Native libraries retain JSON/files, Agreement v2, A2A, trust, text/media, attestation and transport helpers, with package-specific feature gates. Check the relevant language API before assuming a native Rust method is exposed by every wrapper.

Node and Python ship native binaries for the platforms in the release inventory. Go requires CGo, a C toolchain and the matching shared library at build and runtime. Mobile bundle assembly and physical-device acceptance are separate from publishing the jacs-mobile Rust crate.

Build and validate from source

The root commands remain supported:

make build-jacsnpm
make build-jacspy
make build-jacsgo
make test-bindings

They select the separate native workspace and test installed consumers. See the developer commands for broader native test suites and the example index for integration examples. Historical reference chapters can contain earlier package names or CLI commands; current extended CLI examples use jacs-compat.

Rust libraries

Use jacs-core = "=0.15.0" for the no-I/O portable protocol and crypto layer. Use jacs = "=0.15.0" for native filesystem, email, media, trust and integration APIs; enable a2a, agreements or attestation as needed. Both packages are published and supported, with separate dependency graphs.

Start with the native Rust API, document operations, agreements, email signing or storage backends. The portable core guide describes the smaller embedding surface.

The installed portable CLI is jacs; extended command examples use jacs-compat. See packages for the complete inventory and release evidence.

Node.js library

npm install --save-exact @hai.ai/jacs@0.15.0

The package includes native bindings for the released platforms. It supports direct application integration as well as MCP adapters. It is separate from the browser package, @hai.ai/jacs-wasm.

Start with the simple API, instance API or API reference. Framework guides cover Express, Koa, LangChain.js and Vercel AI SDK.

The current package README explains CLI download behavior, public approval verification and request/event authentication. Older reference chapters can contain pre-0.15 registry status; the release inventory records current verified artifacts.

Python library

python -m venv .venv
.venv/bin/python -m pip install jacs==0.15.0

Use the native Python library directly in services, tools and framework adapters. Prebuilt wheels are available for the platforms in the release inventory; custom source builds use maturin and Rust.

Start with the simple API, instance API, framework adapters or API reference.

The current package README covers public approval verification, request/event authentication and the optional CLI shim. Current extended CLI examples use jacs-compat; the shim's downloaded jacs executable is the portable CLI.

Go library

The published module is github.com/HumanAssisted/JACS/jacsgo@v0.15.0. It requires CGo, a C toolchain and the version-matched shared library. In a module that imports github.com/HumanAssisted/JACS/jacsgo:

go get github.com/HumanAssisted/JACS/jacsgo@v0.15.0
go mod vendor
go run github.com/HumanAssisted/JACS/jacsgo/cmd/jacsgo-install@v0.15.0 -version v0.15.0

The installer verifies the native library's checksum and places it in the vendored module. Build with CGO_ENABLED=1 and deploy the matching shared library alongside the executable, as described in the current Go guide. macOS arm64/x86_64 and glibc Linux arm64/x86_64 libraries are released; Windows and musl prebuilt libraries are unavailable.

See the Go API and quickstart, using the current version and installation contract above. go get alone does not install the native library needed for linking and execution.

Browser and mobile

Browser

npm install --save-exact @hai.ai/jacs-wasm@0.15.0

Use the browser guide for WASM initialization, workers, signing/verification and encrypted storage. The npm scope is @hai.ai; older @jacs/wasm examples predate this release. The browser package shares the portable core and does not load the native Node module or expose native email/filesystem integrations.

Android and iOS

jacs-mobile provides UniFFI bindings and platform host libraries. See the mobile guide, Android lifecycle and custody guide and iOS guide.

The hardware-backed platform store protects access to software PQ key material; it does not perform native hardware ML-DSA signing. Publishing the Rust crate is separate from assembling host bundles and accepting behavior on physical devices.

Library and integration reference

The library and integration documentation covers supported Node, Python, Go and Rust APIs, email, media, storage, A2A, attestations and framework adapters. The documentation source remains with the native workspace. Some chapters retain historical installation/version text: use current package guidance and the jacs-compat executable for extended CLI commands.

Jump to A2A, Agreement v2, attestations, email, text, media, trust, storage or observability.

Use extended MCP profiles to determine which tools are actually available at runtime. A compiled tool inventory is not an authorization grant.

Development and releases

From a checkout, make help lists the main build and test entry points. Use make check for dependency boundaries, source version alignment, licensing, notices, release policy and script tests. make test-all exercises the portable workspace; native compatibility suites remain explicit.

make build-wasm creates the browser package; make test-wasm runs headless Chrome tests. make build-jacsbook builds this guide and the preserved native reference. See the developer command reference for prerequisites, native tests and maintenance commands.

All 17 Rust crates and all language packages use one source version. make release-everything triggers six publishing workflows. Run make verify-shipped-release after recording actual published artifacts. Homebrew formula preparation verifies the CLI assets' checksums and source-bound attestations; tap synchronization is a separate workflow.

See the release guide.