# Handover > Handover is a shared, versioned context platform where humans and AI agents can publish work, review files, mention collaborators, and continue from the same durable record. Handover is built for individuals moving work between models, companies sharing context across teams, and agent systems using MCP or HTTP. Revisions are immutable, authorship comes from the authenticated identity, and personal and company organizations are isolated. ## Start here - https://handover.sh/: Product overview and sign in - https://skills.handover.sh/: Installable Agent Skills for creating portable handoff records, verifying connections, publishing, resuming, reviewing, testing, and governing Handover workflows - https://handover.sh/docs: Complete documentation and onboarding - https://handover.sh/guides: Category guides for agent handoff and shared context - https://handover.sh/examples: Working examples filterable by agent host, artifact type, and workflow - https://handover.sh/demo: No-login human-agent continuation demo with downloadable artifacts, revisions, and resolved review - https://handover.sh/demo.json: Agent-readable continuation demo manifest - https://handover.sh/demo/prompt.md: Copyable successor-agent prompt with a bounded response contract - https://handover.sh/about: Factual product and operator identity for Handover and 44pixels Limited - https://handover.sh/install: CLI and host-specific MCP setup for Codex, Claude Code, Gemini CLI, Cursor, and ChatGPT - https://handover.sh/research: Open datasets, field reports, protocols, and runnable evidence about human-agent context continuity - https://handover.sh/research.json: Agent-readable research index with findings, artifacts, status, and limitations - https://handover.sh/security: Organization isolation, identity, credentials, access boundaries, publishing, and privacy-safe measurement - https://handover.sh/benchmark: Open AI Handoff Continuity Benchmark, methodology, and reproducible runner - https://handover.sh/protocol: Open Handoff Continuity Record v1.0 with JSON Schema, valid example, and dependency-free validator - https://handover.sh/roadmap: Factual product and protocol roadmap with available, validating, next, and conditional work - https://handover.sh/roadmap.json: Agent-readable roadmap with status definitions and evidence links - https://handover.sh/templates: Reusable Markdown handoff templates - https://handover.sh/tools: Catalog of private browser tools for handoffs, model switching, governance controls, and evidence review - https://handover.sh/tools/ai-handoff-prompt-generator: Private browser tool that creates a model-neutral handoff record, capture prompt, and resume prompt - https://handover.sh/tools/ai-agent-governance-checklist: Private browser checklist for AI agent identity, access, approval, evidence, verification, revocation, and offboarding controls - https://handover.sh/tools/ai-handoff-readiness-checker: Private browser checker for objective, state, evidence, constraints, next action, receiver verification, and ownership gaps in an existing AI handoff - https://handover.sh/examples/ai-handoff-prompt.md: Raw capture and receiver prompts for AI session continuity - https://handover.sh/examples/ai-handoff-readiness-checklist.md: Raw deterministic readiness checklist for human and agent receivers - https://handover.sh/changelog: Factual product history and release notes - https://handover.sh/case-studies: Measured field reports with disclosed relationships, privacy boundaries, and limitations - https://handover.sh/case-studies.json: Agent-readable case-study evidence and publication policy - https://handover.sh/releases.json: Agent-readable public release feed - https://handover.sh/feed.xml: RSS release feed - https://handover.sh/openapi.json: OpenAPI 3.1 contract - https://handover.sh/agent-tools.json: MCP and agent tool manifest - https://handover.sh/ai-index.json: Question-to-answer knowledge index - https://handover.sh/llms-full.txt: Expanded public knowledge corpus ## Documentation - https://handover.sh/docs/what-is-handover: Handover is a shared, versioned context platform where humans and AI agents can publish work, review it, and continue from the same record. - https://handover.sh/docs/mcp-server: Use Handover's hosted MCP server to let authorized agents search, read, publish, review, and continue shared context. - https://handover.sh/docs/annotations: Annotate exact text and code in a Handover artifact, mention collaborators, and expose actionable review threads to agents. - https://handover.sh/docs/organizations-and-access: Organize company context by product or business area while keeping personal workspaces and company tenants isolated. - https://handover.sh/docs/cli-and-api: Publish folders, pull immutable context, automate continuations, and integrate directly through Handover's CLI and OpenAPI contract. - https://handover.sh/docs/imports-and-exports: Bring GitHub folders and signed HTTP payloads into Handover, then export immutable revisions without changing the canonical record. - https://handover.sh/docs/reporter-migration: Move Reporter products, folders, reports, and MCP publishing workflows into Handover through a staged, reversible migration. - https://handover.sh/docs/security-and-privacy: Understand tenant isolation, Google SSO, service identities, scoped credentials, restricted handovers, and deliberate public publishing. ## Category guides - https://handover.sh/guides/how-to-hand-off-context-between-ai-agents: To hand off shared context between AI agents with MCP, the publishing agent verifies its identity, searches for related work, creates a versioned record with source artifacts, and reads it back. A separately authenticated receiving agent retrieves the current revision and open review, verifies the evidence, and appends a new revision with optimistic concurrency instead of reconstructing the task from chat history. - https://handover.sh/guides/shared-context-vs-agent-memory: Context engineering for AI agents is the practice of selecting, structuring, and delivering the information an agent needs for the current task. Use prompt context for immediate instructions, runtime memory for local recall, shared context for accountable work that crosses people or agents, and source artifacts for evidence. Production systems usually need all four layers, with clear rules for what enters each one. - https://handover.sh/guides/ai-agent-handoff-vs-memory-vs-routing: Agent routing selects who acts next, agent memory retains information for a runtime or user, and a durable handoff transfers responsibility, verified state, evidence, and next actions across actors or systems. They solve different problems and usually work together: route work inside a run, use memory for local continuity, and publish a durable handoff when work crosses a model, session, person, or organizational boundary. - https://handover.sh/guides/handover-vs-handoff-md: A HANDOFF.md file is often enough for one repository, one visibility boundary, and a small sequential workflow. Use a handover platform when several people or agents need authenticated authorship, immutable revisions, attached evidence, review comments, search, or access policy. The two patterns also work together: keep a concise HANDOFF.md in the repository and publish it with the supporting artifacts at important continuation boundaries. - https://handover.sh/guides/human-review-of-ai-agent-output: A reliable human-in-the-loop review workflow preserves the exact AI-generated artifact, anchors each finding to the revision and selected evidence, assigns an authorized resolver, and requires a later immutable revision before the finding is closed. The agent reads open annotations before continuing, and the human can verify which revision addressed each comment. - https://handover.sh/guides/end-to-end-mcp-agent-handoff: An end-to-end MCP agent handoff has ten observable checkpoints: verify the publishing identity, search before creating, publish the source files, read the result back, verify a separate reviewing identity, retrieve the exact revision and artifacts, annotate the evidence, publish a correction with expectedRevisionId, resolve the finding against that correction, and let a successor continue from the new canonical revision. The handoff is not complete merely because the first tool call succeeded. - https://handover.sh/guides/mcp-workflow-for-multi-agent-collaboration: A practical MCP workflow gives every authenticated agent access to the same canonical handoff while keeping each revision attributable. The first agent publishes objective, state, evidence, constraints, and next action; the next agent searches and reads that record, checks open annotations, then continues it with optimistic concurrency instead of starting a disconnected copy. - https://handover.sh/guides/move-context-between-claude-chatgpt-gemini-cursor-codex: To move context between Claude, ChatGPT, Gemini, Cursor, and Codex, publish the work as a provider-neutral handoff, then connect each supported host to the same Handover MCP endpoint or retrieve the record through the CLI. The models do not share hidden memory; they continue from the same explicit objective, state, evidence, constraints, and next action. - https://handover.sh/guides/what-belongs-in-ai-agent-handoff: An AI agent handoff record should contain seven things: objective, current state, decisions, evidence, constraints, next action, and ownership. It should also preserve attached files and unresolved review comments. It should not contain secrets, unrelated transcripts, hidden reasoning, or claims that cannot be traced to evidence. - https://handover.sh/guides/shared-workspace-for-humans-and-ai-agents: A shared knowledge base for AI agents should combine approved source knowledge with a writable continuation layer. Source knowledge grounds answers in company documents; continuation records preserve objectives, decisions, evidence, revisions, feedback, and next actions created by people and agents. Both layers must enforce the same company, workspace, and record-level access rules, with a distinct authenticated identity for every person and unattended agent. - https://handover.sh/guides/service-accounts-for-ai-agents: A service account for an AI agent is a non-human identity used by one unattended agent or automation. It should be named for a single purpose, scoped to the minimum workspaces and actions required, stored outside prompts and artifacts, rotated or revoked independently, and recorded as the author of every action it performs. - https://handover.sh/guides/mcp-oauth-vs-service-accounts: Use OAuth when an interactive person is connecting an MCP client and should approve access under their own identity. Use a named service account when an unattended agent, scheduled job, or shared automation needs stable non-human access. Both approaches should produce a distinct principal, narrow scopes, revocable credentials, and server-side authorship; a person's copied access token should never become an agent identity. - https://handover.sh/guides/version-and-review-ai-generated-reports: Version AI-generated reports by storing every published output as an immutable revision with a named author, timestamp, source evidence, change summary, and review state. Human or agent comments should remain anchored to the exact file and revision reviewed, while corrections are published as a new revision instead of silently replacing the original. - https://handover.sh/guides/mcp-context-server-vs-vector-memory: An MCP context server and vector memory solve different problems. MCP standardizes how an AI host discovers and calls tools or retrieves resources; vector memory ranks semantically similar chunks. Use vector search to find relevant material, use an MCP context server to expose governed context and actions across clients, and combine them when agents need both semantic retrieval and an inspectable system of record. - https://handover.sh/guides/preserve-context-across-ai-coding-agents: Preserve context across AI coding agents by separating stable repository instructions from changing task state. Keep conventions and verification commands in the instruction file each host reads, keep the current objective, decisions, evidence, risks, and next action in a HANDOFF.md record, commit code and tests to Git, then publish the handoff with its supporting files when work crosses a model, machine, person, or access boundary. - https://handover.sh/guides/transfer-context-from-claude-code-to-codex: To transfer context from Claude Code to Codex once, use Codex's built-in import flow: open Settings > Import in the desktop app or run /import in an idle Codex CLI session, choose Claude Code, and select the supported setup, project files, and recent chats. For recurring handoffs, keep the repository in Git, put stable instructions in CLAUDE.md and AGENTS.md, publish changing task state and evidence to Handover from Claude Code, then have Codex retrieve the current revision, verify the checkout, and continue it. - https://handover.sh/guides/mcp-memory-server-for-claude-code-cursor-codex: Use an MCP memory server across Claude Code, Cursor, and Codex by connecting every host to the same remote MCP endpoint with a separate named credential, then testing search, read, publish, and continuation as distinct actors. Handover uses https://handover.sh/api/mcp?profile=core as the endpoint. It preserves canonical files, revisions, annotations, access policy, and authorship rather than storing only an opaque chat summary or a bag of retrieved text chunks. - https://handover.sh/guides/migrate-static-report-folders-to-shared-ai-context: Migrate static report folders by inventorying every collection, entry file, supporting asset, URL, owner, and audience before copying anything. Map broad business areas to Spaces, use folders only for organization, import each report as a stable handover with immutable revisions and original files, verify rendering and hashes, then run the old and new publishing destinations in parallel until human and agent acceptance tests pass. - https://handover.sh/guides/ai-agent-governance-framework: A practical AI agent governance framework maps every agent to an owner, purpose, identity, data boundary, allowed action set, approval rule, evidence trail, and revocation path. Apply the controls at the same interfaces agents actually use: model hosts, MCP servers, APIs, shared context, and publishing workflows. Review risk continuously from inventory through offboarding, and require attributable records for consequential work. - https://handover.sh/guides/agent-skills-and-mcp: Agent Skills and MCP solve different layers of an agent workflow. A SKILL.md packages procedural knowledge: when to activate, which sequence to follow, what evidence to preserve, and how to verify success. MCP provides runtime capabilities: authenticated tools, resources, and data. A dependable integration uses the skill to orchestrate MCP calls, derives identity and access from the MCP connection, handles denied access explicitly, and verifies the resulting record. - https://handover.sh/guides/install-agent-skills-claude-code-codex-cursor-gemini: Use the open skills CLI to install the same SKILL.md into Claude Code, Codex, Cursor, or Gemini CLI, then verify three separate layers: the installer placed the skill in the host's project scope, the host activates the skill from a matching request, and the authenticated MCP server completes and reads back the intended result. A copied skill file alone does not prove the runtime connection or workflow works. - https://handover.sh/guides/test-mcp-server-connection-cli: A useful MCP connection test must verify more than transport. Check the configured endpoint, resolve the authenticated person or service agent, confirm the intended workspace and scopes, and complete a real read against protected context. With the Handover CLI, `handover doctor` performs those checks without printing the credential or changing any handover. - https://handover.sh/guides/ai-agent-handoff-skill: An AI agent handoff skill is a portable SKILL.md workflow that teaches an agent when and how to transfer unfinished work. A complete handoff skill does more than delegate control inside one run: it verifies the active identity, preserves objective, state, decisions, evidence, constraints, next action, and ownership, reads the published result back, and proves that a separately authenticated successor can retrieve and continue it. - https://handover.sh/guides/cline-mcp-server-setup: To add a remote MCP server to Cline, use the MCP Servers panel in the IDE or run the Cline CLI installation wizard with a Streamable HTTP URL. For Handover, connect `https://handover.sh/api/mcp?profile=core`, add one named service-agent credential through Cline's private Static headers prompt, call `handover.whoami`, search and read a known artifact, then create and read back a disposable private handoff. A visible server or tool list alone does not prove authentication, tenant isolation, or durable continuity. - https://handover.sh/guides/gemini-cli-mcp-server-setup: To add a remote MCP server to Gemini CLI, run `gemini mcp add --transport http --scope user`, provide the server URL and any required private header, then inspect it with `gemini mcp list` or `/mcp`. For Handover, connect `https://handover.sh/api/mcp?profile=core` with one named service-agent credential, call `handover.whoami`, read a known artifact, create and read back a disposable private handoff, and require a separately authenticated successor to retrieve and continue it. Connected status proves transport and tool discovery; it does not prove identity, tenant isolation, or continuity. - https://handover.sh/guides/claude-code-mcp-server-setup: To add a remote MCP server to Claude Code, run `claude mcp add --transport http`, put the server name and URL before any `--header` value, and choose user or project scope. For Handover, connect `https://handover.sh/api/mcp?profile=core` with one named service-agent credential, inspect health with `claude mcp list` or `/mcp`, call `handover.whoami`, read a protected artifact, and complete an approved create-and-read-back. A separately authenticated successor must then retrieve and continue the record. An Added or Connected status proves configuration and transport, not identity, tenant isolation, or continuity. - https://handover.sh/guides/cursor-mcp-server-setup: To add a remote MCP server to Cursor, put its Streamable HTTP URL in `~/.cursor/mcp.json` for global use or `.cursor/mcp.json` for one project, then inspect it with `agent mcp list` and `agent mcp list-tools`. For Handover, use `https://handover.sh/api/mcp?profile=core` with one named service-agent credential, call `handover.whoami`, read a protected artifact, and complete an approved create-and-read-back. A separately authenticated successor must then retrieve and continue the record. A configured server, successful command exit, or visible tool list does not by itself prove identity, tenant isolation, or continuity. - https://handover.sh/guides/codex-mcp-server-setup: To add Handover to Codex, run `codex mcp add handover --url https://handover.sh/api/mcp?profile=core` and complete the browser sign-in. Inspect the saved server with `codex mcp list` and `codex mcp get handover`, then call `handover.whoami`, read a known artifact, create and read back one approved private handoff, and require a separately authenticated successor to retrieve and continue it. A configured server or OAuth label proves setup, not identity, tenant isolation, exact retrieval, or continuity. - https://handover.sh/guides/organizational-context-handoff: An organizational context handoff is a controlled transfer of responsibility between teams, people, or AI agents. The sender publishes one canonical, versioned record containing the objective, current state, decisions, evidence, constraints, access classification, next action, and owner. The receiver verifies identity and access, reproduces one material claim, accepts or blocks the transfer, and records the first continuation before the old workflow is retired. ## Templates - https://handover.sh/templates/agent-handoff: A model-neutral checklist and Markdown record for transferring work between agents, tools, or people without losing evidence, constraints, or ownership. Raw Markdown: https://handover.sh/templates/agent-handoff.md - https://handover.sh/templates/production-incident-handoff: A time-sensitive record for transferring an investigation without losing impact, evidence, or mitigations. Raw Markdown: https://handover.sh/templates/production-incident-handoff.md - https://handover.sh/templates/research-handover: A structured record for preserving questions, methods, sources, findings, uncertainty, and follow-up analysis. Raw Markdown: https://handover.sh/templates/research-handover.md - https://handover.sh/templates/agent-review-checklist: A concise checklist for reviewing evidence, assumptions, access, and follow-up before accepting agent work. Raw Markdown: https://handover.sh/templates/agent-review-checklist.md - https://handover.sh/templates/agent-service-account-inventory: A governance record for every unattended agent identity, its owner, scope, credential location, and review lifecycle. Raw Markdown: https://handover.sh/templates/agent-service-account-inventory.md - https://handover.sh/templates/company-ai-context-readiness: A practical checklist for testing shared company knowledge across people and AI agents without weakening identity, access, review, or tenant boundaries. Raw Markdown: https://handover.sh/templates/company-ai-context-readiness.md - https://handover.sh/templates/ai-report-review-record: A revision-aware review record for generated reports and their supporting files, evidence, comments, and disposition. Raw Markdown: https://handover.sh/templates/ai-report-review-record.md ## Working examples - https://handover.sh/demo: Open a no-login demo containing Markdown, SQL, JSON, a visual artifact, three attributable revisions, and a resolved review thread. - https://handover.sh/examples/multi-agent-handoff-workflow.md: Publish a structured handoff, retrieve it from another host, and append the next revision without losing decisions or ownership. - https://handover.sh/examples/end-to-end-mcp-handoff-workflow.md: Publish Markdown, SQL, and JSON, review the exact revision, correct the evidence with optimistic concurrency, resolve the finding, and prove a successor can continue. - https://handover.sh/examples/mcp-memory-server-setup.md: Configure Claude Code, Cursor, and Codex with separate named credentials, then prove a second host can retrieve and continue the first host's work. - https://handover.sh/examples/cline-mcp-server-setup.md: Configure Cline IDE or CLI with remote Streamable HTTP, verify a named service identity, and prove a fresh successor can retrieve and continue the exact artifact. - https://handover.sh/examples/gemini-cli-mcp-server-setup.md: Add a user-scoped remote HTTP server, diagnose disabled and disconnected states, verify a named service identity, and prove a fresh successor can continue the exact artifact. - https://handover.sh/examples/claude-code-mcp-server-setup.md: Add a user-scoped remote HTTP server, diagnose authentication, trust, and enterprise-policy states, then prove a fresh successor can continue the exact artifact. - https://handover.sh/examples/cursor-mcp-server-setup.md: Configure a remote Streamable HTTP server for Cursor IDE and Agent CLI, diagnose connection, environment, disabled, and OAuth states, then prove a fresh successor can continue the exact artifact. - https://handover.sh/examples/codex-mcp-server-setup.md: Add a remote Streamable HTTP server to Codex CLI, the IDE extension, or the desktop app, verify a named service identity, and prove a fresh successor can continue the exact artifact. - https://handover.sh/guides/preserve-context-across-ai-coding-agents: Separate durable repository instructions from changing task state, checkpoint Git evidence, and give the successor an exact verification sequence. - https://handover.sh/examples/claude-code-to-codex-context-transfer.md: Choose between Codex's one-time Claude Code import and a repeatable, revisioned handoff that a fresh Codex session can verify and continue. - https://handover.sh/docs/cli-and-api: Install the Handover command, authenticate once, publish a folder, and pull the same context into another working session. - https://handover.sh/benchmark: Compare transcript, compressed-memory, and structured-handoff conditions with a deterministic continuation benchmark. - https://handover.sh/examples/human-agent-review-loop.md: Publish an artifact, anchor actionable feedback, mention or assign an authorized resolver, and link every resolved finding to the corrected revision. - https://handover.sh/templates/agent-service-account-inventory: Document every service agent, credential owner, scope, rotation date, and revocation path in one reusable record. - https://handover.sh/examples/ai-agent-governance-checklist.md: Assign an owner and risk tier, map identity and access, define approval gates, retain evidence, test controls, and revoke the agent cleanly. - https://handover.sh/docs/imports-and-exports: Export a complete, versioned context bundle and import it into another tool without making Handover the only readable copy. - https://handover.sh/guides/migrate-static-report-folders-to-shared-ai-context: Inventory products, folders, HTML entry points, nested assets, owners, audiences, URLs, and publishing clients before a reversible dual-run cutover. - https://handover.sh/examples/organizational-context-handoff-checklist.md: Transfer responsibility between teams, people, and AI agents with explicit scope, access classification, evidence, receiver acceptance, continuation, and rollback. - https://handover.sh/examples/context-engineering-layer-map.md: Decide whether information belongs in instructions, active working context, runtime memory, shared context, or source artifacts. - https://handover.sh/examples/agent-skill-mcp-workflow.md: Package one reliable Handover workflow in SKILL.md, connect it to authenticated MCP capabilities, and test identity, success, denied access, continuity, and revocation. - https://handover.sh/examples/ai-agent-handoff-skill.md: Install a portable SKILL.md, verify the publishing identity, preserve unfinished work, and prove a separately authenticated successor can retrieve and continue it. - https://handover.sh/examples/cross-host-agent-skill-install.md: Install the same Handover skill into Claude Code, Codex, Cursor, or Gemini CLI, then verify discovery, activation, MCP identity, read-back, denied access, and cross-host continuation. - https://handover.sh/examples/handover-cli-connection-check.md: Check the endpoint, authenticated principal, workspace, role, scopes, and a protected context read, then run a two-identity continuation test. ## Recent releases - 2026-08-09 — Search provenance and safer Reporter migration review: Search results now explain when a match came from attached content or a file name, while Reporter migrations retain conservative review signals for large bundles and uncertain product mappings. - 2026-08-05 — A private readiness check for existing AI handoffs: An existing Markdown handoff can now be checked for the continuation-critical fields another human or AI agent needs before receiver verification. - 2026-08-05 — One inspectable index for Handover evidence: Handover now publishes one human and agent-readable index for its open continuity benchmark, production migration field report, stable handoff protocol, and runnable continuation demo. ## Case studies - https://handover.sh/case-studies/44pixels-reporter-to-handover-migration: 44pixels inventoried 1,497 reports in its existing Reporter system and verified 1,370 as Handover records, or 91.5%. The migration deliberately held 127 reports for review, kept Reporter available, and left cutover blocked rather than guessing through ambiguous mappings. ## Public interfaces - https://handover.sh/api/mcp?profile=core: Hosted streamable HTTP MCP endpoint - https://handover.sh/handover.mjs: Dependency-free Node.js CLI - https://handover.sh/install.sh: Auditable CLI installer - https://handover.sh/recipes/mcp-hosts.json: Machine-readable MCP host recipes - https://handover.sh/examples/mcp-memory-server-setup.md: Copyable Claude Code, Cursor, and Codex setup with an end-to-end continuity test - https://handover.sh/examples/ai-agent-governance-checklist.md: Copyable AI agent inventory, access matrix, approval, control-test, incident, and offboarding checklist - https://handover.sh/examples/multi-agent-handoff-workflow.md: End-to-end multi-agent workflow - https://handover.sh/examples/end-to-end-mcp-handoff-workflow.md: Reproducible multi-identity MCP handoff with Markdown, SQL, JSON, anchored review, correction, resolution, and negative tests - https://handover.sh/examples/ai-agent-handoff-skill.md: Install, activate, and test a portable AI agent handoff skill across separately authenticated hosts - https://handover.sh/examples/cline-mcp-server-setup.md: Configure Cline IDE or CLI with Handover MCP, verify identity, and run a two-agent continuity test - https://handover.sh/examples/gemini-cli-mcp-server-setup.md: Configure Gemini CLI with Handover MCP, diagnose disabled or disconnected states, verify identity, and run a two-agent continuity test - https://handover.sh/examples/claude-code-mcp-server-setup.md: Configure Claude Code with Handover MCP, diagnose authentication, trust, and enterprise-policy states, verify identity, and run a two-agent continuity test - https://handover.sh/examples/cursor-mcp-server-setup.md: Configure Cursor IDE or Agent CLI with Handover MCP, diagnose connection, environment, OAuth, and disabled states, verify identity, and run a two-agent continuity test - https://handover.sh/examples/codex-mcp-server-setup.md: Configure Codex CLI, the IDE extension, or the desktop app with Handover MCP, verify environment-backed authentication, and run a two-agent continuity test - https://handover.sh/examples/ai-handoff-prompt.md: Copyable prompt for producing a verified continuation record and a bounded receiver workflow - https://handover.sh/examples/organizational-context-handoff-checklist.md: Copyable sender, receiver, access, acceptance, continuation, and rollback runbook for cross-team human-agent transfers - https://handover.sh/examples/organizational-context-handoff-checklist.json: Machine-readable organizational handoff stages, evidence requirements, pass rule, and block rules - https://handover.sh/demo/context.md: Raw Markdown context from the public continuation demo - https://handover.sh/demo/inventory.sql: Raw SQL from the public continuation demo - https://handover.sh/demo/evidence.json: Structured evidence from the public continuation demo - https://handover.sh/benchmark/v1/dataset.json: Versioned continuity benchmark dataset - https://handover.sh/benchmark/v1/run.mjs: Deterministic benchmark prompt generator and scorer - https://handover.sh/benchmark/v1/results/2026-08-04/summary.json: Machine-readable two-model pilot results and limitations - https://handover.sh/benchmark/v1/results/2026-08-04/README.md: Reproducibility record and links to all raw model responses - https://handover.sh/benchmark/v1/CITATION.cff: Citation metadata for the benchmark dataset - https://handover.sh/benchmark/v1/citation.bib: BibTeX citation for papers and technical writing - https://handover.sh/benchmark/v1/results/2026-08-04/summary.csv: Flat result table for analysis and reuse - https://github.com/44-pixels/handover-mcp/tree/main/benchmark/v1/independent-results: Frozen-method package standard for publishing an independent benchmark result - https://github.com/44-pixels/handover-mcp/issues/new?template=independent-benchmark-result.yml: Guided independent-result submission - https://handover.sh/protocol/v1/schema.json: JSON Schema Draft 2020-12 contract for a Handoff Continuity Record - https://handover.sh/protocol/v1/manifest.json: Stable protocol version, scope, license, canonical source, and artifact map - https://handover.sh/protocol/v1/example.json: Valid machine-readable continuity record - https://handover.sh/protocol/v1/validate.mjs: Dependency-free structural conformance checker - https://handover.sh/protocol/v1/README.md: Producer, receiver, scope, and security requirements ## Important product facts - Handover is canonical; GitHub, Reporter, signed HTTP, and OKF are interoperability layers. - Humans and agents use the same collaboration and access model. - Mentions create notifications but never grant access. - Public reports require an explicit publication action. - Unattended agents use named, revocable, scoped service credentials.