> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wipe.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Using Wipe.me with AI agents

> Keep credentials and private files out of agent conversations while work happens on remote machines.

Imagine that you ask Claude Code or Codex to deploy an application on a remote
server. The server needs a GitHub Container Registry token to pull your private
image. During setup, it creates a PostgreSQL password that you need to save.

Without a private handoff, both values may be pasted into the agent conversation and
retained in model context, task history, tool logs, or observability systems. With
Wipe.me, the conversation carries one-time private links instead. Wipe.me handles
the sensitive values on the remote machine, beside the tools that use or create
them.

## What are you trying to do?

<CardGroup cols={2}>
  <Card title="Send a secret to a remote agent" icon="arrow-right" href="/use-cases/human-to-agent">
    Give a remote deployment tool an API token or credential without pasting its plaintext into the agent conversation.
  </Card>

  <Card title="Receive a secret from a remote agent" icon="arrow-left" href="/use-cases/agent-to-human">
    Receive a generated database password, recovery artifact, or VPN configuration on your notebook.
  </Card>

  <Card title="Transfer between remote agents" icon="network" href="/use-cases/agent-to-agent">
    Move a signing key, deployment token, or private artifact between agents on different machines.
  </Card>
</CardGroup>

## What stays out of the conversation?

The agent can coordinate the operation using a private link, file path, environment
variable name, and non-secret completion status. It does not need the underlying API
token, password, private key, or file contents in its model context.

For example, when you send a GitHub Container Registry token to a remote deployment
agent:

1. You create a Wipe.me message on your notebook and paste its private link into the
   agent conversation.
2. Wipe.me on the remote server consumes the message into the deployment
   environment.
3. The agent authenticates `docker` to `ghcr.io`, pulls the private image, and starts
   the service without receiving the token in its tool result.
4. The conversation retains only the link, which stops working after the one-time
   retrieval.

When the direction is reversed, Wipe.me encrypts a password or private artifact on
the remote server. The agent returns the link, and you open it on your notebook.

<Warning>
  An unopened automatic private link is a bearer credential. Anyone with the complete
  link can attempt to retrieve the message. For a less-trusted conversation channel,
  use Custom mode and share its passphrase separately.
</Warning>

## How Wipe.me runs with the agent

Install Wipe.me in the **remote environment where the agent is doing the work**:

* If that agent environment supports MCP, connect the `wipeme mcp` stdio server
  there. The agent receives structured operations that do not return plaintext.
* If the agent reaches the machine through SSH, a terminal, or a runner, use the
  Wipe.me CLI on that remote machine.

Both interfaces use the same Wipe.me executable and local encryption. Choose based
on how the agent controls the remote environment—not on a different security model.

<CardGroup cols={2}>
  <Card title="MCP server" icon="bot" href="/developer-tools/mcp-server">
    Connect Wipe.me to a compatible agent environment.
  </Card>

  <Card title="Command-line interface" icon="terminal" href="/developer-tools/command-line-interface">
    Use Wipe.me through remote shells, deployment runners, and automation.
  </Card>
</CardGroup>