Your workbench.
VibePackr connected.

One connection, clear responsibilities.

Read the current downloads, host guides and Tool MCP scope before connecting an extension. No extra model, resident service, GPU control computation or multi-agent scheduler is required.

The PoC package installs on your own compatible VM in AWS, Azure, GCP or on-premises; no cloud marketplace listing or subscription is required. The current server target is Debian 13 amd64/x86_64 with systemd. Your team provides the required installation privileges, storage and network access. Google sign-in to the download portal does not require GCP hosting. This describes the deployment model, not a qualification of every cloud configuration.

Keep the customer’s workbench. Use native VibePackr operations for integration analysis and product work, and CALF for local execution records and file validation. CALF is the worked example; the same boundaries apply to another customer application.

This exercise runs two linked stages: native analysis, then a local report task. It does not require an AI agent. A real product Work follows the separate product Work handoff after the report exercise.

What you need before you start.

Start here after the PoC common installation and workspace setup. The setup owner hands over the following installation-specific values once; operators then follow download, connection and verification below. Keep these values in the private PoC handoff, not in the public guide.

integration-lab/
  VibePackr-Workbench-Examples/   # extracted companion
  CALF-SDK-0.2.6/                # separately downloaded SDK
  private/connection.json       # your verified native descriptor pins
  capture-01/                   # created by capture_analysis.py
  binding-01/                   # created by bind_report.py prepare
  records/                      # shared CALF records for this exercise

Create the integration-lab and private folders first using your file manager; choose a location accessible only to your user. The example creates capture/binding output folders and refuses to overwrite existing ones.

For the first exercise use a new records folder. To show existing work later, select its exact existing home. Preserve history.html, contracts, settings and retained runtimes; do not copy or edit private state files to connect an application.

Download, verify, open.

Read https://www.vibepackr.com/poc/workbench/install.md.
Prepare the CALF client for this PoC reference lab on my actual OS: Workbench 1.9.9 (or Harness 1.8.13) and SDK 0.2.6.
Preserve existing records, contracts, settings and runtimes. Verify downloads, native version/help and SDK import in new folders.
Report actual paths/results and missing prerequisites. Keep host settings, model calls and existing task execution outside this first installation.

Also download SDK 0.2.6, the release SHA256SUMS, and SDK-SHA256SUMS. Headless users can choose Harness 1.8.13.

1. Compare the downloaded archive’s SHA-256 with the exact filename in the official manifest. Keep the original archive.
2. Extract the complete Workbench and SDK into separate versioned folders. The example commands below use placeholders: replace every absolute path before running.

shasum -a 256 CALF-Workbench-1.9.9-macos-arm64.zip
shasum -a 256 CALF-SDK-0.2.6.zip
unzip CALF-Workbench-1.9.9-macos-arm64.zip
unzip CALF-SDK-0.2.6.zip
# Set actual absolute paths after extraction:
CALF="/absolute/CALF-Workbench-1.9.9-macos-arm64/CALF Workbench.app/Contents/MacOS/calf"
SDK="/absolute/CALF-SDK-0.2.6"
EXAMPLES="/absolute/VibePackr-Workbench-Examples"
LAB="/absolute/integration-lab"
export CALF_WORK_HOME="$LAB/records"
"$CALF" --version
# Start from this terminal so this window receives the same records home:
"/absolute/CALF-Workbench-1.9.9-macos-arm64/CALF Workbench.app/Contents/MacOS/calf-terminal"

Get-FileHash .\CALF-Workbench-1.9.9-windows-x86_64.zip -Algorithm SHA256
Get-FileHash .\CALF-SDK-0.2.6.zip -Algorithm SHA256
Expand-Archive .\CALF-Workbench-1.9.9-windows-x86_64.zip -DestinationPath .\workbench-199
Expand-Archive .\CALF-SDK-0.2.6.zip -DestinationPath .\sdk-026
# Set actual absolute paths after extraction:
$Calf = 'C:\absolute\CALF-Workbench-1.9.9-windows-x86_64\calf.exe'
$Sdk = 'C:\absolute\CALF-SDK-0.2.6'
$Examples = 'C:\absolute\VibePackr-Workbench-Examples'
$Lab = 'C:\absolute\integration-lab'
$env:CALF_WORK_HOME = Join-Path $Lab 'records'
& $Calf --version
& 'C:\absolute\CALF-Workbench-1.9.9-windows-x86_64\calf-terminal.exe'

sha256sum CALF-Workbench-1.9.9-linux-x86_64.tar.gz
sha256sum CALF-SDK-0.2.6.zip
tar -xzf CALF-Workbench-1.9.9-linux-x86_64.tar.gz
unzip CALF-SDK-0.2.6.zip
# Set actual absolute paths after extraction:
CALF="/absolute/CALF-Workbench-1.9.9-linux-x86_64/calf"
SDK="/absolute/CALF-SDK-0.2.6"
EXAMPLES="/absolute/VibePackr-Workbench-Examples"
LAB="/absolute/integration-lab"
export CALF_WORK_HOME="$LAB/records"
"$CALF" --version
"/absolute/CALF-Workbench-1.9.9-linux-x86_64/calf-terminal"

Connect the native VibePackr endpoint.

Download and extract the examples below. The connection Adapter uses Python’s standard library, launches one native stdio child on demand, discovers the actual tools, and closes it after use. It does not open an HTTP port or install a daemon.

1. Ask the setup owner for the generated mcp-server.json, its verified SHA-256 and the matching packr-agent-mcp SHA-256. Keep the referenced registration/catalog in their private locations.
2. Copy connection.example.json to private/connection.json and fill the three values below. A locally computed hash helps compare bytes; it does not establish publisher trust by itself.
3. Run setup status once. Inspect the returned native envelope and discovered catalog before proceeding.

{
  "descriptor": "/absolute/private/vibepackr-setup/mcp-server.json",
  "descriptor_sha256": "REPLACE_WITH_VERIFIED_DESCRIPTOR_SHA256",
  "adapter_sha256": "REPLACE_WITH_VERIFIED_NATIVE_EXECUTABLE_SHA256"
}

python3 -B "$EXAMPLES/calf_vibepackr.py" \
  --connection "$LAB/private/connection.json" \
  --tool vibepackr.setup.status --operation-ref guide:setup-001 \
  --request "$EXAMPLES/empty-request.json"

py -3 -B "$Examples\calf_vibepackr.py" `
  --connection "$Lab\private\connection.json" `
  --tool vibepackr.setup.status --operation-ref guide:setup-001 `
  --request "$Examples\empty-request.json"

python3 -B "$EXAMPLES/calf_vibepackr.py" \
  --connection "$LAB/private/connection.json" \
  --tool vibepackr.setup.status --operation-ref guide:setup-001 \
  --request "$EXAMPLES/empty-request.json"

Run one registered analysis.

Use the allowed input ID supplied by the setup owner. This example calls vibepackr.sdk.analyze for a complete registered integration request. It does not send an arbitrary local path, prompt or token. The companion saves the original envelope, call identity and connection observation as UTF-8 files.

python3 -B "$EXAMPLES/capture_analysis.py" \
  --connection "$LAB/private/connection.json" \
  --input-id YOUR_REGISTERED_INPUT_ID \
  --operation-ref guide:analysis-001 --output "$LAB/capture-01"

py -3 -B "$Examples\capture_analysis.py" `
  --connection "$Lab\private\connection.json" `
  --input-id YOUR_REGISTERED_INPUT_ID `
  --operation-ref guide:analysis-001 --output "$Lab\capture-01"

python3 -B "$EXAMPLES/capture_analysis.py" \
  --connection "$LAB/private/connection.json" \
  --input-id YOUR_REGISTERED_INPUT_ID \
  --operation-ref guide:analysis-001 --output "$LAB/capture-01"

Bind the result to a checked file version.

The next step is a separate CALF report task. Its input is the captured native response. The runtime Adapter creates native.json and report.json without contacting VibePackr again. Seven native checks bind the original bytes, exact report fields, successful analysis and absence of an appliance Work/approval claim.

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" prepare \
  --input "$LAB/capture-01/native-result.json" --output "$LAB/binding-01"

py -3 -B "$Examples\bind_report.py" --sdk "$Sdk" `
  --calf "$Calf" --records "$env:CALF_WORK_HOME" prepare `
  --input "$Lab\capture-01\native-result.json" --output "$Lab\binding-01"

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" prepare \
  --input "$LAB/capture-01/native-result.json" --output "$LAB/binding-01"

1. Prepare: register the pinned interpreter/script and write work-spec.json. No candidate is executed yet.
2. Run: use Workbench in the next section, or the SDK command below. Do not run both as separate new tasks.
3. Inspect: require verified: true, outcome: SATISFIED and matching manifest/check digests. A submitted work or executor exit 0 is insufficient.
4. Adopt: select the exact checked digest explicitly. This selects a local file version; it does not deploy or overwrite source files.

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" run \
  --spec "$LAB/binding-01/work-spec.json" --result "$LAB/run-01.jsonl"

py -3 -B "$Examples\bind_report.py" --sdk "$Sdk" `
  --calf "$Calf" --records "$env:CALF_WORK_HOME" run `
  --spec "$Lab\binding-01\work-spec.json" --result "$Lab\run-01.jsonl"

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" run \
  --spec "$LAB/binding-01/work-spec.json" --result "$LAB/run-01.jsonl"

See the same work in Workbench.

1. Open Workbench with the same CALF_WORK_HOME used by the SDK. Choose Runtime Work.
2. For a prepared-only task, choose Import contract… → binding-01/work-spec.json → Add work, then run the offered action. If the SDK already ran it, choose Refresh and the existing work instead.
3. Inspect stages, both artifacts, seven checks and Evidence JSON. Verify the report scope and exact digest before Adopt checked version.
4. Reopen the same records home to inspect retained evidence. The task ID and adopted digest should remain the same.

Current CALF overview · A4

Public capability overview for the 11 November release. The terminal drawing is a conceptual layout, not a capture of this integration exercise. Open the original image to read the full-size text.

Earlier actual Runtime Work screen · 1.9.2

After adoption, inspect adoptedValid as well as the current outcome. The adopted object preserves historical selection even if later file changes make it invalid.

Let an MCP-capable host inspect CALF.

The generated binding-01/work-mcp.json is a launch descriptor. Merge it as a named entry through your host’s supported MCP settings. It is not an entire settings file and the SDK does not install it automatically. CALF Workbench 1.9.9 does not offer arbitrary external MCP-server registration.

{
  "command": "/absolute/path/to/calf",
  "args": ["work-mcp", "/absolute/integration-lab/records"]
}

On Windows, use the absolute calf.exe path and escaped backslashes in JSON. Keep one selected records home. Add "--control" to args only when the host is authorized to submit/step/cancel/retry/recheck/adopt. Adapter registration remains local API/SDK only.

Bind your own customer workbench.

A workbench with MCP support can use the native descriptors. A workbench with a local process/API extension can use the SDK. Keep one agent and one shared records home; no extra agent scheduler, vector database or resident model is needed. The thin integration owns presentation and IDs, while each native product retains its own decisions.

Python · inspect before adoption

import json
from pathlib import Path
from calf_sdk import CalfClient

# Run with the extracted CALF-SDK-0.2.6 on Python's module path.
client = CalfClient("/absolute/calf", "/absolute/records", timeout=35)
spec = json.loads(Path("work-spec.json").read_text(encoding="utf-8"))
accepted = client.work("submit", spec=spec)  # frozen; not executed
client.work("step", work=accepted["work"])
result = client.work("inspect", work=accepted["work"])
if result.get("verified") is True and result.get("outcome") == "SATISFIED":
    digest = result["manifest"]["digest"]
    print("Ready for explicit adoption:", accepted["work"], digest)
# After the user's explicit adoption action:
# client.work("adopt", work=accepted["work"], digest=digest)

Node.js · read the same record

import {CalfClient} from './CALF-SDK-0.2.6/node/index.mjs';
const client = new CalfClient('/absolute/calf', '/absolute/records');
const result = await client.work('inspect', {work: 'work-<actual ID>'});
console.log(JSON.stringify({
  verified: result.verified,
  outcome: result.outcome,
  manifest: result.manifest,
  adopted: result.adopted,
  adoptedValid: result.adoptedValid
}, null, 2));
// A transport exception has unknown effects; do not auto-retry a mutation.

VibePackr connection binding

from calf_vibepackr import Connection

with Connection.from_config("/absolute/private/connection.json") as native:
    result = native.call("vibepackr.sdk.analyze", "analysis:stable-001",
                         {"input_id": "registered-input"})
    # Keep these separate in your application:
    transport = result["transport_status"]
    product = result["product_result"]
    reconciliation = result["reconciliation"]
    # Persist the complete result, including null and false values.
    # No automatic retry and no manufactured PASS/receipt.

To support another runtime, implement calf.runtime.v1 in a registered argv-based Adapter. It receives one request-file path and emits one bounded JSON result. Independent checks define acceptance. The supplied SDK examples include Python, Node and loopback HTTP; asynchronous runtimes must query the original request ID after uncertain submission.

From a checked report to real product Work.

The exercise ends with a checked analysis report. To execute a real VibePackr Work, the setup owner must supply the supported installation connection, registered runtime and exact contract/approval path. An SDK-generated mapping candidate or CALF-adopted report does not supply those prerequisites.

1. Discover the actual VibePackr catalog. Updated packages may expose manual Work phases; older packages do not gain tools from this guide.
2. Use the installed package’s BOOTSTRAP.md and Work guide for supported input formats, runtime binding and authorized phase progression. Retain each native reason and next action.
3. Link the customer request, CALF work/attempt, VibePackr operation and original product Work reference. Keep product receipts separate from CALF check receipts.
4. Complete only when that native Work’s validation, recovery state and required approval/receipt are confirmed. Preserve unknown, pending and refused states.

If the next step is blocked.

1. After an interrupted native analysis

First read the existing capture files. These commands only display local JSON and do not call VibePackr. Run the second command only if error.json exists; its absence does not establish success. Keep the same terminal variables from installation.

python3 -m json.tool "$LAB/capture-01/intent.json"
# Only if error.json exists:
python3 -m json.tool "$LAB/capture-01/error.json"

py -3 -m json.tool "$Lab\capture-01\intent.json"
# Only if error.json exists:
py -3 -m json.tool "$Lab\capture-01\error.json"

python3 -m json.tool "$LAB/capture-01/intent.json"
# Only if error.json exists:
python3 -m json.tool "$LAB/capture-01/error.json"

There is no generic reconciliation command in this companion. Supply the original operation ID, tool, input ID and retained error to the setup owner. For real product Work, use only the query supported by its installed catalog and original product reference. A new capture folder is a place to preserve a confirmed result, not a reason to retry.

2. After CALF submitted the report task

Find the existing work ID in the accepted.work field of the first line of run-01.jsonl, or in Workbench Runtime Work using the same records home. Replace WORK_ID below. If the run file is missing or partial, inspect the existing list first; do not delete it to rerun submission.

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" inspect --work WORK_ID

py -3 -B "$Examples\bind_report.py" --sdk "$Sdk" `
  --calf "$Calf" --records "$env:CALF_WORK_HOME" inspect --work WORK_ID

python3 -B "$EXAMPLES/bind_report.py" --sdk "$SDK" \
  --calf "$CALF" --records "$CALF_WORK_HOME" inspect --work WORK_ID

Inspection checks current record/file identity without running the report Adapter again. Keep an active or busy task unresolved until its current state is known. If evidence is stale, resolve the changed input, Adapter or candidate, then use the existing task’s supported Recheck action; do not substitute an old successful receipt. Only adopt when the current result is verified and SATISFIED with the exact current digest. This report contract allows one attempt; it does not authorize an unlimited retry loop.

Versions, evidence and companion files.

Checked on 11 November 2026 on macOS ARM64 with released Harness 1.8.13 and SDK 0.2.6: the report Adapter passed seven checks for a synthetic captured-analysis envelope, rejected an Err fixture, adopted an exact digest and exposed the same record through Python, Node and read-only Work MCP. A changed candidate returned UNKNOWN and adoptedValid=false while preserving adoption history. This compatibility check made no fresh native VibePackr analysis or AI/provider call and completed no customer appliance Work.

The current CALF core and SDK releases have separate macOS ARM64, Windows x64 and Linux x64 qualification. That does not qualify the VibePackr reference binding on all three OSes. This guide provides platform-specific commands; use a matching native VibePackr package and verify the actual customer installation.

Native VibePackr references used: supplied MCP_SETUP.md, BOOTSTRAP.md and the existing CALF local Adapter contract. This PoC subsection documents the optional customer-workbench integration path. No live customer data, private connection files or proprietary core source is included.

The original example archive remains available for reproducing the dated reference. Use the current versioned companion for this walkthrough; do not merge it into an existing example folder.Original ZIP