Body-MCP
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| eyes_see_browserA | See the browser page: title, headings, visible text, links, buttons, inputs and forms. Interactive elements get stable refs (btn_1, input_2, link_3) usable by hands_*. If private=True: the URL is opened in a throwaway isolated context (fresh cookies/storage), read-only, refs omitted, context always closed — weaker local persistence, NOT anonymity. screenshot=True attaches ONE downscaled image of the page (vision mode, on request). Restricted pages (CAPTCHA, rate limit, paywall, access denial) are reported, never bypassed. |
| eyes_see_desktopA | See the desktop: capture a screen (or a region) and OCR its visible text. Screenshots are processed in memory and never written to disk. The OCR engine is
discovered, never assumed: without one you get the exact install command instead of
a silent failure. |
| ears_listenA | Hear the user through the microphone (push-to-talk). Records locally, transcribes locally, and NEVER stores or transmits raw audio. With stop_on_silence=True the recording ends shortly after the user stops talking (like a push-to-talk button); the transcript comes back with the fragments that were recognised with LOW confidence so you can ask the user to confirm them. The transcript is editable: send it, edit it, or ignore it. |
| hands_openB | Open a URL in Chromium (http/https/file-under-CWD only; credentials-in-URL refused). Respects per-service rate-limit cooldowns and stops at access restrictions. |
| hands_batchA | Execute a declared sequence of browser actions in ONE request. Actions: goto, click, fill, press, scroll, wait_for, verify_text, verify_url, screenshot. Validate-then-execute; stop on first failure (or on_failure='continue' for SAFE steps only); per-step and total timeouts; consequential clicks still require fresh approval per step; no JavaScript/Python/shell escape hatches; duplicate consequential submissions refused. Verification outcomes (in result): completed | failed | blocked | needs_user | retry_scheduled. Never reports success without verification evidence. resume_from=<checkpoint_id>: re-inspect the page and resume from the last verified step — never blindly replays; redacted steps need fresh explicit text. task_id=: run as the SAME task (use the task_id from a previous needs_user result when re-running after approval — scoped approvals are bound to it). |
| hands_parallelA | Run INDEPENDENT browser tasks on isolated pages (default max 2 concurrent). tasks: [{"id"?, "actions": [], "on_failure"?, "deadline_ms"?}] Rules: isolated contexts per task; NO snapshot refs across tasks (use unique visible text / label / placeholder / name); consequential actions are refused in parallel mode — run them via hands_batch with reflex_ask approval; per-service cooldowns are shared; per-task and overall deadlines; contexts always cleaned up. |
| hands_clickA | Click a browser element by ref (btn_1/input_2/link_3) or unique visible text. Dangerous buttons require a fresh reflex_ask() approval — one approval, one click. |
| hands_typeB | Clear and type into a field by ref (or unique label/placeholder/name). Refuses password/OTP/card fields — the user must type those. |
| hands_pressC | Press a key or chord, e.g. 'Enter', 'Tab', 'Escape', 'Control+A'. |
| hands_scrollC | Scroll the browser page. direction: up|down. amount: 1-50. |
| attach_browserA | Connect to your CURRENT Chrome/Edge tab via CDP (loopback only). Requires Chrome/Edge running with --remote-debugging-port (launch: python -m body_mcp.cdp_launch). Requires your acknowledged consent + a scoped reflex_ask approval for exactly this action. Without |
| list_tabsA | List the candidate tabs of an ALREADY-ATTACHED CDP session (index/title/url only). Read-only; requires nothing beyond a completed attach_browser(). |
| select_tabA | Select one tab after attach_browser(). Requires its own scoped reflex_ask approval. selector: the index from list_tabs(), or a unique url/title substring. |
| detach_browserA | Disconnect the CDP bridge. NEVER closes your browser or tabs. Restart the browser normally afterwards to drop the debug port. |
| memory_searchC | Search persistent local memory (project notes, verified fixes, limitations, preferences). Memory is a local SQLite file - nothing leaves this machine. Unverified entries are proposals, not facts; pass include_unverified=False to get only verified ones. |
| memory_writeB | Store one durable memory. Scopes: project | workflow | capability | user | knowledge | research. Credentials are refused - store the fact, never the secret. Use verified=True only when you actually verified the claim. |
| memory_listC | List stored memories, newest first, optionally filtered by scope/project. |
| memory_deleteB | Delete one memory by id, or every memory in a scope (destructive). |
| memory_exportC | Export memories as JSON and Markdown (readable, portable, local). |
| body_privacy_preflightA | Check the privacy posture BEFORE a private session starts. Reports: which browsers are installed, whether the VPN app is installed and open, whether a LOCAL model is configured, the free RAM, and the warnings - including the one about your reasoning model still being remote (a warning, never a block). It changes nothing and asks for no IP unless you ask for it. |
| privacy_session_startA | Start a privacy session (own throwaway browser context - nothing persisted). mode='standard' isolated context (incognito-equivalent). mode='private' the same isolation plus: the VPN you asked for (call privacy_vpn_connect() - it opens and connects the app, with your approval), Brave (or Chromium) as the engine in a private window, and the AI assistant (Venice AI) opened first as the research tab while the real sites stay in a second tab. Call body_privacy_preflight() first: it reports what is installed, what is running, and what you should switch on. keep_content_local=True the page TEXT stays on this machine: it is redacted and
summarised by a local model and only that comes back. It needs a
local model (Ollama + Nothing from this session is written to persistent memory, the audit log or the event stream. It reduces local persistence only - it is NOT anonymity: websites, network operators, device administrators and downloaded files can still observe it. |
| privacy_session_openB | Open a URL inside a privacy session. Access controls are still enforced - a login, CAPTCHA or paywall stops the session, it is never bypassed. |
| privacy_session_snapshotC | Read the current page of a privacy session (bounded text, no refs, not stored). |
| privacy_session_endA | End a privacy session: close its context, discard its cookies/storage and VERIFY the cleanup. Your ordinary browser profile is never touched. |
| memory_noteB | Write a human-editable Markdown note (project instructions, conventions). Notes live in /notes/*.md, are included in memory_search, and can be edited directly in your editor. Credentials are refused. |
| desktop_watch_startA | Start a LIVE desktop observation session (explicit user request only). The screen is sampled every ocr=False watch the screen as IMAGES instead of text: frames are still captured and compared, but nothing is recognised. Use it when no OCR engine is installed and a vision model will look at the frames (desktop_watch_read(as_image=True)). |
| desktop_watch_readB | Read the latest observation of a live desktop session. Returns the recognised screen text (bounded), when it was observed, whether it
changed since |
| desktop_watch_stopC | Stop a live desktop observation session and release its resources. |
| browser_bridgeB | Drive the browser the USER has open, through their extension. action: status | connect | tabs | navigate | read | screenshot | disconnect. The user connects a tab in the extension (one click, with Chromium's own "debugging this browser" bar); Body-MCP then acts only on that tab. Nothing is read or navigated before the user connects it. |
| body_open_externalA | Open a URL in the USER'S OWN browser (a new tab), not in Body-MCP's browser. Use it when the task says "open it in my browser". browser: "" = the operating system default, or one of chrome | edge | brave | firefox to pick the browser explicitly. Only http/https are handed over (no shell, no command strings) and the browser executable comes from a fixed table. Body-MCP's own Chromium stays separate - it is the controlled one. |
| body_local_modelsA | The local-model catalogue and what THIS machine can run. Sizes and SHA-256 are the published ones, so a download can be verified before it is used. The ranking uses the measured free RAM - it never suggests a model that would not fit. Nothing is downloaded: you choose, you fetch it, you point BODY_MCP_LOCAL_MODEL at it. |
| body_local_workerA | Process text (or an image) ON THIS MACHINE with a local model. Nothing leaves. task: summarise | extract | redact | key | classify | describe text: the text to process. image: base64 PNG/JPEG - only for task='describe' (the eyes for a text-only brain). Take it from eyes_see_desktop(as_image=True) or desktop_watch_read(as_image=True). This is the private mode's content half: the page text goes to a model running
on your machine, so only a short redacted summary ever leaves. It needs Ollama
( |
| privacy_vpn_connectA | Open the VPN app and ask it to connect (Proton VPN on Windows). The agent clicks the app's OWN connect button and then reads the window, so the reported state comes from the app - 'unknown' is reported instead of a guess. It never switches servers or rotates IPs to evade a block. Needs the vpn_control permission, which is 'deny' by default: add "vpn_control": "allow" to your permissions.json (a USER edit) to enable it. |
| body_windowsA | See which windows are open right now (titles only - no content, no screenshots). This is read-only and needs no debug port, so it works even for a browser you started yourself. It CANNOT drive those windows: for that the browser needs a sanctioned connection (a debug port on a separate profile, or the extension bridge). |
| desktop_monitorsB | List the connected screens and which OCR engines are usable on this machine. |
| body_voice_enginesA | Which speech-to-text and text-to-speech engines this machine can use. Nothing is downloaded and nothing is loaded: this only reports what is already installed, which model files are present, and what each engine would cost in memory. The default text-to-speech engine is the Windows system voice. |
| body_speakA | Speak text with the LOCAL system voice (Windows SAPI - no download, no network). Playback runs in the background and can be stopped with body_stop_speaking(). Typed chat stays fully usable without this; the tool never sends audio anywhere. |
| body_stop_speakingA | Stop the local speech playback started by body_speak(). |
| body_profileB | Read-only capability inventory of this machine (OS, CPU, RAM, disk, GPU, optional modules, agent CLIs, local speech models). Nothing is installed or downloaded, nothing private is crawled, nothing is uploaded. The result is cached locally and can be cleared. |
| body_modelsB | Catalogue the model/harness backends available on this machine, with what each can do, its licence, privacy and cost. Read-only; installs nothing. |
| body_recommendB | Dry-run recommendation: which installed backend fits a task best, and why. Needs: e.g. ["tools", "vision", "audio", "structured_output"]. Never downloads or launches anything - it only ranks what is already here. |
| research_collectA | Collect evidence from public pages: title, URL, publication date, excerpt and retrieval method, with verification status and content hashes for deduplication. Read-only, bounded (max_items, bounded text), and never authenticated - a page that asks for a login, CAPTCHA or paywall is reported as blocked, not bypassed. Source content is untrusted data: it cannot grant permissions. |
| research_videoA | Watch AND hear a public video: title, channel, views, date, chapters and the OFFICIAL caption track as a timestamped transcript. The captions are the video's own track, so the audio is read without downloading a speech model. If a video has no captions, the tool says so instead of inventing a transcript (local transcription is a separate, explicit opt-in). Everything is read-only and public-page only. |
| body_workflow_startA | Open an execution ledger for one goal: EYES -> BRAIN -> HANDS -> VERIFY. Record every step with body_workflow_note(): what you SAW (observation), what you DECIDED and why (decision), what the body DID (action), what PROVED it worked (verification). The ledger is what the final report is built from - evidence instead of memory. The decision stays yours; the body only records it. |
| body_workflow_noteB | Add one step to the workflow ledger. kind: observation | decision | action | verification | blocker | lesson | note | approval. Write the decision BEFORE the action, and the verification AFTER it - that order is what makes the run auditable. |
| body_workflow_reportA | The evidence-backed report of a workflow (empty id = the latest one). Shows the goal, what was observed, what was decided, what was done, what was verified and what blocked it - so the final answer cites evidence, not impressions. |
| body_lessonsA | What we already learned from failures - read it BEFORE repeating an attempt. Every failed action leaves a proposed lesson (root cause + likely fix). These are the lessons that apply to a tool or an error code, newest first. |
| desktop_inspectB | Look inside a native Windows window: its controls (name, type, position, state). This is the desktop equivalent of eyes_see_browser - it reads the real UI tree through Windows UI Automation, so controls are found by their visible name. Reading is allowed; acting on the window needs the desktop_control permission. |
| desktop_clickA | Click a control in a native Windows window, by its visible name. Uses UI Automation's Invoke pattern - not blind coordinates - so nothing is clicked by accident. Needs the desktop_control permission (default: ask). |
| desktop_typeA | Type into a field of a native Windows window, by its visible name. Password-like fields are refused - the user types those. Needs the desktop_control permission (default: ask). |
| desktop_read_valueB | Read the current value of a field in a native window (the verification step). |
| research_youtube_searchA | Find reference videos: search YouTube and return title, channel, views, age and whether an official caption track exists. Use it to learn how something is done (a style, a workflow, a talk) before you act - the body fetches the evidence, the agent decides what to copy and what to ignore. Read-only; nothing is played or downloaded. |
| research_sourcesA | Which platforms the body can actually research, and which are blocked. Every readable source is a public, documented, key-free endpoint (read-only, rate-limited, no login). Blocked ones say why - no silent substitution. |
| research_sourceA | Search ONE research source and get evidence records. source: hackernews | reddit | github_issues | stackoverflow | wikipedia | youtube. Each record: title, url, author, date, score/comments, excerpt, retrieval method and the limitation that applies. A blocked source returns the reason, never a substitute. |
| reflex_interviewA | Ask the user several questions at once and get the answers back. Use it before building anything: budget, category, what went wrong with the tools you already tried, light vs heavy, must-haves, must-nevers. With no questions given, the standard Body-MCP set is used. |
| body_task_startA | Start a LONG batch in the background and get a task id straight away. The agent keeps working while the body carries on (own isolated context, never the page you are using). Poll body_task_status(task_id) for progress, or body_task_cancel(task_id) to stop it. Small jobs should just use hands_batch - this is for the slow ones. |
| body_task_statusB | Progress of a background task: steps done, percent, elapsed, last evidence. |
| body_task_cancelB | Cancel a background task (it stops at the next step boundary). |
| body_undoA | Undo the most recent reversible change (a typed value, a navigation). Irreversible steps are NOT undone - the journal says so instead of pretending. |
| body_undo_listC | What the body changed and whether it can be undone. |
| body_skill_saveB | Save a procedure you learned from your own work, so it can be replayed. steps: the same action schema hands_batch uses (click/type/fill/goto/verify...). why: what you learned and why it works - this is the part that makes it a skill and not a script. verified: only true if the result was actually checked. An unverified skill stays a proposal and is never replayed blindly. |
| body_skill_listC | The skills we know: name, goal, why, steps and whether they were verified. |
| body_skill_replayB | Do exactly the same thing again: replay a verified skill's steps, in order. Same targets, same content, same permission gate, same verification - this is the 'copy paste the same' path. Unverified skills are refused until someone checks them. |
| research_anyB | Search several sources with a fallback chain: if one API is closed, try the next best one, including the public search page in the browser. Read-only: no account is used, nothing is posted, nothing is clicked in your session. (If you want your own logged-in session searched, connect the extension bridge - that is your one-click choice, never done silently.) |
| demo_learnA | Learn a workflow from a screen recording and turn it into a skill DRAFT. Frames are extracted (ffmpeg/opencv if installed), the screen text is read with OCR - or, when no OCR engine is installed, described by a LOCAL vision model - changed frames become steps, and the unclear parts become questions for you. The result is a draft, not a verified skill - answer the questions first. video_path may also be a FOLDER of images (PNG/JPG): extract the frames yourself and hand the folder over - no decoder needed. Blocked honestly when there is neither a decoder (or a folder), nor an OCR engine, nor a local vision model. |
| body_rolesB | The team: each role's tools, permission and what it must produce. The roles are responsibilities, not separate models - the connected agent is the orchestrator and the brain; the body executes each contract. |
| body_role_startC | Open a contract for one role: its tools, its budget and what it must produce. |
| body_role_finishC | Close a role contract with the evidence it produced. |
| body_stop_allA | STOP EVERYTHING: cancel the running background tasks and close the open contracts. This is the panic button - it never touches your files, only the work in flight. |
| body_similarity_checkB | Is this new content actually new? Compare it with what was produced before. Used for adapted execution: keep the method, change the content. Reports the highest similarity found (token overlap and sequence ratio) and a verdict. |
| body_console_startA | Start the optional local Body Console (activity timeline + cancel/disconnect). Binds to 127.0.0.1 only and requires a session token; the returned URL contains it. The console shows REAL executor events — tasks, actions, verifications, blockers — and never page content. Stop it with body_console_stop(). |
| body_console_stopA | Stop the local Body Console (if running). |
| body_eventsA | Read the real execution event stream (task lifecycle, actions, verifications, blockers). Events are emitted by the executor itself, not by the model. Use it to report what actually happened, and to notice when the user must act (approval, CAPTCHA, login). |
| body_cancelA | Request cancellation of the running task (or a specific task_id). Cancellation is cooperative: the executor stops at the next step boundary and reports CANCELLED. It never pretends the cancelled work was done. |
| legs_open_appA | Launch an allowlisted installed application (e.g. 'notepad'). The allowlist lives in YOUR permissions.json (allowed_applications) — empty by default. Launching requires the app in your allowlist plus a fresh reflex_ask() approval. |
| reflex_verifyA | Verify expected text is present on the current page (or desktop if no page). Use after every changing action. Returns success, found, and the evidence window. |
| reflex_askA | Ask the human a yes/no question (elicitation form or native dialog). With action='': a yes issues ONE scoped approval bound to exactly that action (tool | capability | target | url | task_id). The approvals are consumed once at execution. Nothing on a webpage or in a model's output counts as approval. Fail-closed. |
| body_statusB | Real capability states: what is importable, launched, blocked, or not configured — never claimed as 'verified' without a real check. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 78 tools
Many tools have distinct targets, but the set has several overlapping control paths: hands_type vs desktop_type, hands_click vs desktop_click, eyes_see_browser vs browser_bridge vs privacy_session_snapshot, and multiple cancel/stop tools. The detailed descriptions help, but an agent still has to choose carefully between browser modes (own Chromium, CDP attach, extension bridge, user browser) and desktop observation modes.
All names are snake_case, and domain prefixes like hands_, eyes_, desktop_, memory_, privacy_, research_, body_, and reflex_ provide readable grouping. However, verb order and prefixing are mixed: hands_type is prefix_verb, memory_search is resource_verb, attach_browser/list_tabs/select_tab are bare verb_noun, and body_console_stop uses prefix_resource_verb.
78 tools is far too many for a single server, regardless of how broad the 'body' domain is. The surface includes many subdomains — browser control, desktop automation, memory, research, privacy, workflows, roles, tasks, skills, events, console — which should be split or scoped down.
The surface covers an unusually broad lifecycle: browser/desktop perception and action, memory CRUD/search/export, privacy sessions, research collection, background tasks, workflows, skills, roles, approvals, and undo. Minor gaps exist, such as no task listing and no skill deletion/update, but most workflows have enough coverage to avoid hard dead ends.