Your privacy choices

We use necessary cookies, and others only if you allow them. You can change your mind at any time.

Feature · Humans and agents, one surface

Human+: one UI, two kinds of operator

A person and an agent work in the same interface and trade control. The agent reads and writes the components' own state through MCP bridges, never by scraping the page, and every change it makes is visible, undoable, and, where it matters, a proposal the person confirms.

ReactNode / TypeScriptPHP
react-fancy ContentReaction + registerContentReactionBridgeLive · in-page MCP

Click a reaction yourself, then send the agent a tool call: both change the same controlled value. Turn on Ask me first and the agent's write waits for your Approve. agent_undo takes back the agent's last change and only the agent's. Nothing here leaves the page.

What it is made of

Each claim is checkable in agent-integrations and the packages named below.

28 bridges, not scraping

Each surface has a register<Surface>Bridge(server, { adapter }) that turns the host's own getters and setters into MCP tools: forms, sheets, flow, whiteboard, slides, terminal, git, maps, the CMS and the rest. The agent changes the same controlled state the person's clicks change.

Presence and activity

Bridge mutations go through wrapToolWithActivity, which broadcasts an AgentActivity event naming what was touched, so presence, highlighting and coaching layers compose for free. fancy-auto-common holds those shared primitives; fancy-screens carries an agent's presence across screens.

Undo, per agent

Every bridge installs agent_undo, agent_redo and agent_history. Each agent has its own stack, so undoing an agent's change never takes back the person's.

Propose, then confirm

Destructive or human-visible writes can be staged instead of applied: pendingMode on the reaction, form and terminal bridges (terminal_confirm, terminal_reject), proposal-first writes on the git bridge, staging on the CMS bridge. The passkeys bridge can only propose a revoke, and no tool completes a sign-in ceremony.

Co-browse the app itself

The navigation bridge lets an agent read, focus, click and navigate the running app through page_* and nav_* tools. It refuses every action inside a region marked data-agent-off-limits, such as a consent banner.

Reach from outside the page

A relay transport carries MCP frames between the browser and an agent anywhere. fancy-cf-relay keeps that channel alive behind a CDN by switching between SSE and long-poll, and mcp-relay-client is a single-file client in bash, Python, TypeScript and Go.

Review what an agent changed

fancy-diff shows a document diff side by side with per-hunk accept and reject, so a person takes an agent's edit one hunk at a time.

On-The-Fly UI

The CMS builds pages by configuration rather than code, which is what lets an agent build UI while the app runs: it edits data, and the renderer shows the result.

A page is configuration

A fancy-cms page is one JSON document (a PageDoc): a flat map of nodes with per-breakpoint style props. Every edit is one PageOp through a pure reduce(). CmsPage renders whatever document it is handed, and fancy-cms renders the same document to the same HTML in PHP. Building a page is writing data, not shipping code.

Charlotte edits the configuration

Charlotte, the website-builder agent kit, edits a page's draft through nine closed tools, with every write pinned to a revision, so a person editing at the same time is never overwritten. Autonomy is your setting: full applies each edit at once, approve_on_save collects them in a change set a person approves. Nothing it does publishes; publishing is one explicit host call.

Where the configuration lives

fancy-cms stores nothing itself: the host owns persistence. Charlotte keeps each draft and its published copy in your database by default, and takes your own PageRepository to keep pages in your schema. A document can also be rendered without being stored at all: the CMS feature's editor renders its live document with CmsPage and never saves it.

Every bridge, and the packages around them

agent-integrations is the MCP server, the bridges, presence and the relay; the other packages are the shared primitives, transports, review and page-building surfaces that sit on it.

Human+ bridge

An agent drives this surface over MCP, through the same state a person sees, never the DOM.

  • import { registerNavigationBridge } from "@particle-academy/agent-integrations/bridges/navigation";tools: page_* / nav_*
  • import { registerFormBridge } from "@particle-academy/agent-integrations/bridges/forms";tools: form_*
  • import { registerScreensBridge } from "@particle-academy/agent-integrations/bridges/screens";tools: screens_*
  • import { registerScreenDocBridge } from "@particle-academy/agent-integrations/bridges/screen-doc";tools: screen_*
  • import { registerDocBridge } from "@particle-academy/agent-integrations/bridges/doc";tools: <surface>_* (get_node / set_props / …)
  • import { registerCmsBridge } from "@particle-academy/agent-integrations/bridges/cms";tools: cms_*
  • import { registerWhiteboardBridge } from "@particle-academy/agent-integrations/bridges/whiteboard";tools: whiteboard_*
  • import { registerArtboardBridge } from "@particle-academy/agent-integrations/bridges/artboard";tools: artboard_*
  • import { registerFlowBridge } from "@particle-academy/agent-integrations/bridges/flow";tools: flow_*
  • import { registerSheetsBridge } from "@particle-academy/agent-integrations/bridges/sheets";tools: sheet_*
  • import { registerGridBridge } from "@particle-academy/agent-integrations/bridges/grid";tools: grid_*
  • import { registerCodeBridge } from "@particle-academy/agent-integrations/bridges/code";tools: code_*
  • import { registerChartsBridge } from "@particle-academy/agent-integrations/bridges/charts";tools: chart_*
  • import { registerSlidesBridge } from "@particle-academy/agent-integrations/bridges/slides";tools: deck_* / slide_* / element_*
  • import { registerSceneBridge } from "@particle-academy/agent-integrations/bridges/scene";tools: scene_*
  • import { registerMapBridge } from "@particle-academy/agent-integrations/bridges/map";tools: map_*
  • import { registerFilesBridge } from "@particle-academy/agent-integrations/bridges/files";tools: files_*
  • import { registerTerminalBridge } from "@particle-academy/agent-integrations/bridges/terminal";tools: terminal_*
  • import { registerTuiBridge } from "@particle-academy/agent-integrations/bridges/tui";tools: tui_* / human_plus_events_*
  • import { registerGitBridge } from "@particle-academy/agent-integrations/bridges/git";tools: git_*
  • import { registerCatalogBridge } from "@particle-academy/agent-integrations/bridges/catalog";tools: catalog_*
  • import { registerFeaturesBridge } from "@particle-academy/agent-integrations/bridges/features";tools: features_*
  • import { registerPasskeyBridge } from "@particle-academy/agent-integrations/bridges/passkeys";tools: passkey_*
  • import { registerContentReactionBridge } from "@particle-academy/agent-integrations/bridges/content-reaction";tools: reaction_*
  • import { registerCoworkBridge } from "@particle-academy/agent-integrations/bridges/cowork";tools: cowork_*
  • import { registerSignBridge } from "@particle-academy/agent-integrations/bridges/sign";tools: sign_*
  • import { registerTemplateBridge } from "@particle-academy/agent-integrations/bridges/template";tools: tpl_*
  • import { registerAgentChatBridge } from "@particle-academy/agent-integrations/bridges/agent-chat";tools: chat_* / hitl_list / knowledge_search

Install

Start with agent-integrations and the bridge for your surface; add the rest as you need them.

  1. agent-integrationsReact
    npm install @particle-academy/agent-integrations
  2. @particle-academy/fancy-auto-commonNode / TypeScript
    npm install @particle-academy/fancy-auto-common
  3. fancy-screensReact
    npm install @particle-academy/fancy-screens
  4. fancy-diffReact
    npm install @particle-academy/fancy-diff
  5. @particle-academy/fancy-cf-relayNode / TypeScript
    npm install @particle-academy/fancy-cf-relay
  6. mcp-relay-clientNode / TypeScript
    npm install mcp-relay-client
  7. fancy-devtoolsReact
    npm install @particle-academy/fancy-devtools
  8. fancy-pixelReact
    npm install @particle-academy/fancy-pixel
  9. particle-academy/fancy-cmsPHP
    composer require particle-academy/fancy-cms
  10. fancy-cms-uiReact
    npm install @particle-academy/fancy-cms-ui
  11. particle-academy/charlottePHP
    composer require particle-academy/charlotte

The packages

agent-integrationsReact

MCP-driven agent presence — micro-MCP server, bridges, presence layer, share relay.

@particle-academy/fancy-auto-commonNode / TypeScript

Shared Human+ primitives — AgentActivity events, presence, undo stacks, and effect helpers. Low-level plumbing reused across the kit; usually installed transitively.

fancy-screensReact

Multi-screen application shell with cross-screen agent presence.

fancy-diffReact

Human+ side-by-side document diff with hunk acceptance — a client-side, zero-dep diff engine or a git unified-diff datasource.

@particle-academy/fancy-cf-relayNode / TypeScript

CDN-safe browser relay channel for agent-integrations' RelayTransport. Adaptive SSE↔long-poll with Cloudflare detection, so the MCP relay survives a Cloudflare/HTTP-3 edge that resets long-lived SSE streams. Zero runtime deps.

mcp-relay-clientNode / TypeScript

Super-lite, single-file MCP client (bash / Python / TS / Go) for connecting an agent to a session-based relay — drive any agent-integrations-hosted app (e.g. the Agent Playground) from your terminal. Download one file, or run the zero-install npx CLI; point it at a session URL.

fancy-devtoolsReact

Suite-aware React diagnostics — structured runtime problems, query and Human+ timelines, redacted exports, and one shared snapshot for humans and agents.

fancy-pixelReact

Embeddable Showcase verification badge + liveness/collection beacon — Badge / Mark / Beacon styles, placed or floating, Shadow-DOM isolated. Drops in via a <script> tag or mountPixel().

particle-academy/fancy-cmsPHP

Laravel host + PHP page renderer for the Stages doc model: node tree → HTML with island hydration; backend pair of the fancy-cms-ui editor. Pre-1.0 — the API may still move between minors; issues at github.com/Particle-Academy/fancy-cms/issues.

fancy-cms-uiReact

WYSIWYG CMS editor (React) for the Stages doc model: three-pane layers / canvas / inspector editing where every mutation is one PageOp through a pure reducer, plus the CmsPage / CmsRegion renderers with $bind data fields that name their live source. Pairs with the particle-academy/fancy-cms PHP renderer. Pre-1.0 — the API may still move between minors; issues at github.com/Particle-Academy/fancy-cms-ui/issues.

particle-academy/charlottePHP

Charlotte: a headless website-builder agent kit for Laravel on prism-harness and fancy-cms. Agents edit DRAFTS (nothing publishes on a change), autonomy is your setting (full, or approve on save), invented and missing facts are caught in code, and an ordered event log long-polls behind any proxy, so you can build your own chat. Any Prism provider; cost telemetry optional. Pre-1.0.

Make your surface one an agent can share

Read why Human+ works this way, then the engineering half: controlled state, stable handles, a bridge and activity events.