Pachakutech Presence
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Pachakutech PresenceHighlight the login button on my screen for five seconds"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Pachakutech Presence — an MCP Binding for the Presence Layer
Not another agent harness. A Presence Layer: a small, typed, policy-gated set of actions — Manifestations — through which an agent can put sensory stimuli directly into your UI instead of only describing it in text. This package is the MCP Binding: the same substrate also binds to AppFunctions on Android and App Intents on iOS, but this is the one that runs on your desktop, today, against whatever agent you're already running.
Install
npm install -g @pachakutech/presence-mcp
presence setup claudepresence setup claude runs claude mcp add presence -- presence mcp for
you. For Codex, presence setup codex does the equivalent. On Omarchy
specifically, see docs/omarchy.md for a one-line install
via omarchy-mise-install.
Run presence doctor any time to check what this machine can support —
today that's informational only (see below), but it's the same check the
native daemon will depend on once it exists.
Related MCP server: mcp-interactive-ui-server
What it exposes
Tool | Pattern | Does |
| ephemeral | Highlights described on-screen content for N seconds |
| instanced (1/3) | Spawns a persistent audio-visual presence derived from context (optionally from a held artifact), returns a |
| instanced (2/3) | Feeds new content to a spawned presence |
| instanced (3/3) | Ends a presence and frees its slot |
| instanced (1/2) | Adds a Gaussian splat cloud (or other content asset) to the substrate as reference material — held, not rendered directly, for |
| instanced (2/2) | Removes a held artifact and frees its slot |
Full schemas are in src/index.ts; the reasoning behind the
ephemeral/instanced split, why artifacts are a separate registry from
presences, and why the tool list stays fixed while what each tool generates
stays wide open is in skills/presence/SKILL.md.
Where this runs, and what it needs access to
The MCP server is local — spawned as a subprocess of your agent CLI, on
your machine, over stdio. There is no cloud round-trip and nothing to
authenticate; the same reason this differs architecturally from something
like Astra is that there's no server to stand up and no session to hand
over. Because your agent CLI runs inside your own logged-in desktop session,
the MCP server it spawns inherits that session's environment automatically —
WAYLAND_DISPLAY, XDG_RUNTIME_DIR, DBUS_SESSION_BUS_ADDRESS — with no
separate setup step, unlike a systemd service, which would need its
environment imported explicitly.
Today, none of that matters yet — src/daemonStub.ts only calls
notify-send and appends to a log file, so the only real dependency is
Node.
Once the native daemon exists (see docs/architecture.md), it will need
two more things, both standard on a modern desktop session and checked by
presence doctor:
GPU access, via the DRM render node (
/dev/dri/renderD128) — for Vulkan. On most current distros this is granted automatically to whoever is logged in at the console, throughsystemd-logind's dynamic ACLs, not through group membership. If it isn't, adding your user to therendergroup fixes it.Webcam access, via
/dev/video*— gated by thevideogroup on most distros. Desktop users are typically in this group already; worth knowing explicitly, since a missing webcam permission fails silently rather than with a clear error.
Neither requires root, a privileged daemon, or a setup wizard — just the ordinary permissions of an interactively logged-in desktop user.
A packaging note: this has no dependency on Arch/pacman specifically, or on any particular init system. If Omarchy's packaging base changes, none of the above changes with it — Hyprland has full first-class support under NixOS and Home Manager as of today, so a Nix-based Omarchy would run this exactly the same way.
What's real vs. stubbed right now
The MCP surface — schemas, the Policy Gate, tool registration, and now the
presence CLI itself — is real and runnable today, on any machine with
Node. The rendering underneath each Manifestation is currently a stand-in
(src/daemonStub.ts): a desktop notification plus a structured log, standing
in for a native Vulkan daemon that doesn't exist yet. That daemon —
zero-copy webcam/screen ingress via dma_buf, output composited through
wlr-layer-shell — is a small, separate build, described in
docs/architecture.md. The boundary between the two is deliberate: the
daemon owns the GPU, the MCP layer owns the contract, and they talk over a
small, typed protocol rather than sharing buffers directly. Swapping the
stub for the real daemon changes nothing above that boundary.
Why this exists
Every agent CLI today speaks fluently in files, shells, and text. None of them have a vocabulary for situational presence — putting something into the user's perception — a highlight, a persistent character, a spatial cue — governed by the same kind of explicit, inspectable contract you'd expect from any other tool call. This is that vocabulary, built as an open MCP server rather than a pitch deck, because the fastest way to have this conversation with anyone is to hand them something that already runs.
MIT licensed. Contributions and forks welcome.
Available Tools
6 toolsaddArtifactAdd a reference artifactA
Instanced Manifestation, step 1 of 2 (add / retire). Adds a Gaussian splat artifact (or other content asset) to the substrate as reference material — it is held, not rendered. Use this to give spawnPresence something concrete to build from (e.g. 'this is what I want the presence to look like') rather than describing appearance in prose. Returns an artifactId.
| Name | Required | Description | Default |
|---|---|---|---|
| sourceUri | No | Where the content came from, if applicable | |
| description | Yes | What this artifact is/depicts |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It usefully discloses that the artifact is 'held, not rendered', returns an artifactId, and is part of a 2-step lifecycle. It does not mention persistence, ordering constraints, or permission requirements, but the core observable behavior is clearly communicated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is focused and each sentence earns its place, including the return value and the concrete example. It is slightly dense with the phrase 'Instanced Manifestation' and the parenthetical lifecycle note, but remains efficient and readable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool, the description is largely complete: it covers the resource, the behavior, the intended use case, and the return value. It leaves minor questions about sourceUri applicability and any side effects, but does enough for an agent to select and call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the two parameters, so the schema already explains sourceUri and description. The description adds value by showing the intended content of the description parameter: 'this is what I want the presence to look like'. It does not add anything specific about sourceUri.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a precise action: 'Adds a Gaussian splat artifact (or other content asset) to the substrate as reference material'. It also distinguishes this tool from siblings by explaining the artifact is 'held, not rendered', and positions it as step 1 in an add/retire lifecycle.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance: 'Use this to give spawnPresence something concrete to build from' and contrasts with 'describing appearance in prose'. The add/retire pairing also implicitly names retireArtifact as the opposite operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
animatePresenceDrive an existing presenceA
Instanced Manifestation, step 2 of 3. Feeds new content (e.g. words to say) to a presence created by spawnPresence.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | What the presence should say or express next | |
| presenceId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It states it 'feeds new content' and is 'step 2 of 3', which implies mutation but not the clarity of whether it modifies state irreversibly. It doesn't omit major behavioral aspects, but lacks details like whether it is asynchronous, or if it returns a confirmation. This is a neutral, not very rich disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence, front-loaded with the purpose and step. It gives a concrete example of input ('words to say') without verbosity. Every word earns its place, and it is appropriately targeted for the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the 2-parameter schema and a clear lifecycle context, the description is fairly complete. It doesn't have an output schema, but for a feeding operation, an agent can infer it returns nothing. It lacks details on return value or behaviour on non-existent presenceId, but this is minor given the overall simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: parameter 'text' has a description, but 'presenceId' does not. The description adds meaning by relating 'text' to 'words to say', which partly compensates for the schema gap; however, 'presenceId' remains semantically weak. Baseline is 3 since coverage is moderate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'feeds' and the resource 'presence', and it identifies its place in a 3-step process. It differentiates from siblings by mentioning 'spawnPresence' and 'retirePresence', though it doesn't explicitly contrast with them. The title 'Drive an existing presence' also reinforces the action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implies usage as step 2 of 3, after spawnPresence Illustrates when to use, but it doesn't provide explicit when-not-to-use or alternatives. The context is clear enough to understand the lifecycle, but there is no mention of conditions to avoid using or of the sibling 'manifestHighlight'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
manifestHighlightHighlight something on screenA
Ephemeral Manifestation. Draws a bounded, temporary highlight over the described on-screen content. Prefer this over describing a location in text when the user can see their screen.
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | What to highlight, e.g. 'the red error banner' | |
| durationSeconds | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the behavioral burden. It discloses 'ephemeral' and 'temporary' to indicate the non-persistent nature of the highlight, but it does not explicitly state that the tool modifies no underlying state or that the highlight fades without side effects. This leaves some room for agent interpretation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two concise sentences. The first imparts the core action and scope, and the second offers a practical usage tip. There is no fluff, and the information is front-loaded, making it easy for an agent to scan and apply.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple drawing tool with no output schema, the description covers the core behavior and usage preference. It could mention the optional duration parameter or its bounds explicitly, but those are already in the input schema. The tool's behavior is sufficiently explained, though there is no clarification about its relationship to sibling manifestation tools, which slightly detracts from completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%; the description parameter is already well documented (with an example), and the tool description aligns with it ('described on-screen content'). However, the description says nothing specific about durationSeconds beyond the schema's default/range, so it does not add meaningful semantic value to that parameter. Since the coverage is exactly at the threshold, the description provides only marginal added insight.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Draws a bounded, temporary highlight over the described on-screen content', identifying the specific action and target. However, it does not directly differentiate from sibling tools such as spawnPresence, so it falls short of full 5 for sibling awareness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The sentence 'Prefer this over describing a location in text when the user can see their screen' gives a clear context for when to use this tool. It does not mention alternatives like sibling manifestation tools, but the guidance is explicit about a common alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
retireArtifactRetire a reference artifactB
Instanced Manifestation, step 2 of 2. Removes a held artifact and frees its slot.
| Name | Required | Description | Default |
|---|---|---|---|
| artifactId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It clearly indicates a destructive operation ('Removes') and the slot-freeing effect, but it does not mention irreversibility, idempotency, error behavior, or any side effects beyond the slot release.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise and front-loaded with the key action. The phrase 'Instanced Manifestation, step 2 of 2' adds workflow context, though it is slightly cryptic. Overall, every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter operation, the description is adequate but has clear gaps: it does not describe what happens if the artifact is not held, whether the retire is reversible, what response to expect, or how this step connects to the full manifestation workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema contains only artifactId with no documentation, so the description partially compensates by clarifying that the removed entity is a 'held artifact.' This makes the artifactId's role inferable, but the description does not explicitly state that artifactId is the identifier of the artifact to retire or explain any format expectations.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Removes a held artifact') and the resource ('artifact'), with an additional consequence 'frees its slot.' The phrase 'step 2 of 2' provides context but does not clearly differentiate this tool from sibling tools like retirePresence.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage within a two-step workflow ('step 2 of 2'), suggesting it should follow a prior manifestation step. However, it does not explicitly state when to use this tool versus alternatives such as addArtifact or retirePresence, leaving the choice to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
retirePresenceEnd a presenceA
Instanced Manifestation, step 3 of 3. Cleanly ends a presence created by spawnPresence and frees its slot. Always call this when the presence is no longer needed — concurrent live presences are capped.
| Name | Required | Description | Default |
|---|---|---|---|
| presenceId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the operation is 'clean' and frees a slot, implying it's not destructive in a harmful way but is a cleanup action. It does not mention any side effects like throwaway resources, idempotency, or failure behavior, so it's adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. The first sentence is front-loaded with the verb and purpose, and the second provides the usage guidance. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter cleanup tool, the description is complete enough. It explains the lifecycle context (step 3 of 3), the benefit (frees slot), and the necessity (concurrency cap). It does not detail the output or error states, but given no output schema and the clear action, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is only one parameter, presenceId, with 0% schema description coverage, but the description implies it identifies the presence to retire by referencing 'a presence created by spawnPresence.' It doesn't state that presenceId must be a valid ID from a previous spawn, but the context is reasonable. The description adds minimal extra meaning beyond the schema's property name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Cleanly ends a presence'), the resource it applies to ('created by spawnPresence'), and its role in a sequence ('step 3 of 3'). It does not explicitly distinguish from siblings like retireArtifact, but the context of presence is specific enough to avoid confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides an explicit 'when to use' directive: 'Always call this when the presence is no longer needed.' It also explains the rationale — 'concurrent live presences are capped' — signaling that cleanup is important. However, it does not describe when NOT to use it (e.g., if the presence is already ended) or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
spawnPresenceSpawn a persistent presenceA
Instanced Manifestation, step 1 of 3 (spawn / animate / retire). Creates a persistent presence derived from the given context (e.g. 'a character based on what's on screen'). Optionally built from a held artifact (see addArtifact) rather than derived fresh. Returns a presenceId — pass it to animatePresence and retirePresence. The generative work (what the presence actually looks like) happens inside this contract; the contract itself never changes.
| Name | Required | Description | Default |
|---|---|---|---|
| styleHint | No | Optional style guidance | |
| artifactId | No | Optional id from addArtifact — use this artifact's content as the basis | |
| sourceContext | Yes | What to derive the presence from |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It does disclose that the presence is persistent, that generative work happens 'inside this contract,' and that 'the contract itself never changes,' plus the return of a presenceId. However, it omits side-effect details such as whether an artifact is consumed, whether spawning twice overwrites, or permission requirements, and the final sentence is somewhat cryptic.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with lifecycle context before diving into parameters and return values. The final sentence about 'generative work' is somewhat vague and may not earn its place as clearly as the rest, but overall the structure is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters, no annotations, and no output schema, the description covers the essential context: what it creates, how it relates to addArtifact, what it returns, and what to do with that return value. It is reasonably complete, though a note about error conditions or idempotency would make it fully self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers 100% of parameters, and the description adds meaning beyond it: it gives a concrete example for sourceContext, explains that artifactId is an alternative to fresh derivation, and clarifies that styleHint is optional. This enriches the bare schema descriptions without redundancy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb and resource: 'Creates a persistent presence derived from the given context.' It also positions the tool as 'step 1 of 3 (spawn / animate / retire)' and references animatePresence and retirePresence by name, making it easy to distinguish from the siblings and from addArtifact.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The lifecycle is explicit: this is step 1, the returned presenceId feeds animatePresence and retirePresence, and the tool can be used either from fresh context or from a held artifact via addArtifact. It does not explicitly state when not to use it (e.g., versus manifestHighlight), so the guidance is clear but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v0.1.0- First observed
addArtifact - First observed
animatePresence - First observed
manifestHighlight - First observed
retireArtifact - First observed
retirePresence - First observed
spawnPresence
TDQS
Scored across 6 tools
Each tool targets a distinct resource and lifecycle stage: artifacts are added/retired, presences are spawned/animated/retired, and manifestHighlight covers a separate ephemeral display. The lifecycle hints in the descriptions make the boundary between artifact management and presence management clear.
All six tools use a consistent camelCase verb-noun pattern, such as addArtifact, retirePresence, and spawnPresence. The resource-specific roots (artifact, presence, highlight) are kept uniform, so there are no mixed conventions or vague generic verbs.
Six tools is well-scoped for a presence server: two artifact lifecycle tools, three presence lifecycle tools, and one ephemeral display tool. Each tool serves a distinct purpose, and none feels redundant or like filler.
Core lifecycles are covered: artifacts have add/retire, presences have spawn/animate/retire, and the highlight feature is available for ephemeral display. The only notable gap is the lack of a list/query tool for current artifacts or active presences, but agent workflows can work around that with returned IDs.
Related MCP Connectors
Human-in-the-loop approval for agent actions, with verifiable action-bound receipts.
Policy gate and signed trust receipts for autonomous agent actions.
Agent governance with A2A/Shopify/MCP trust audits, action screening, and decision UI.
A witness layer for AI agent tool calls.
Related MCP Servers
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to create visual, interactive interfaces with diagrams, structured input forms, and persistent state management instead of text-only responses.7-
- AlicenseAqualityDmaintenanceEnables AI agents to render interactive user interfaces such as forms, dashboards, charts, tables, and wizards directly in MCP-compatible clients. Supports structured data collection and richer interactions beyond text responses.6MIT
- AlicenseNot gradedqualityAmaintenanceEnables AI agents to generate and serve ephemeral, interactive user interfaces over MCP through natural language descriptions.40Apache 2.0
- FlicenseNot gradedqualityBmaintenanceEnables AI agents to render native-looking floating dialogs and forms on the user's desktop, capturing user interactions like button clicks and form inputs.-