> ## 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.

# Remote agent to human

> Receive credentials and private artifacts created on a remote machine without putting their plaintext in the agent conversation.

You ask an AI agent to work on a remote server, cloud development environment, or
build runner. During that work, the remote machine creates a password, recovery
bundle, or private configuration that you need on your notebook.

This is where Wipe.me is useful: the sensitive value starts somewhere you cannot
simply save it to a local file. Wipe.me encrypts it on the remote machine, and the
agent returns a one-time private link through the same conversation you already use
to coordinate the work.

## How the handoff works

1. You ask the remote agent to perform a specific operation.
2. Wipe.me runs beside the sensitive value on the remote machine.
3. The local CLI or MCP server encrypts the value without returning its plaintext to
   the model.
4. The agent posts only the private link in your Claude Code, Codex, or other agent
   conversation.
5. You open the link on your notebook and save the result where it belongs.

The conversation may retain the private link, but an automatic link stops working
after its one-time retrieval. Until then, it is a bearer credential: anyone with the
complete link can open the message. For a channel you do not fully trust, use a
[separately shared Custom-mode passphrase](/use-cases/human-to-human#keep-an-ongoing-conversation-private).

## Initialize PostgreSQL and receive the password

You are using Claude Code or Codex through a terminal connected to a remote
application server. You ask the agent to initialize PostgreSQL for a new service.
The application and you both need the same new database password.

> Initialize the production database with a new generated password. Store it as
> `DATABASE_PASSWORD` in the application's protected environment file, run the
> initialization, and give me the password only as a Wipe.me link.

On the remote machine, the [Wipe.me MCP server](/developer-tools/mcp-server)
generates one password, writes or injects it into the approved destination, and
releases the private link only after the local handoff succeeds. The agent posts
that link in the terminal conversation. You open it on your notebook and save the
password in your password manager.

| Participant                           | Receives                                          |
| ------------------------------------- | ------------------------------------------------- |
| Remote PostgreSQL/application process | The generated password through its environment    |
| AI agent and its transcript           | The private link and non-secret completion status |
| You                                   | The password after opening the link               |

With MCP, use `generate_secret_into_env_file` for a reusable environment file or
`generate_secret_into_process_env` for one approved command. With a remote shell,
the ordinary CLI provides the equivalent generated-password workflow.

## Receive HashiCorp Vault bootstrap credentials

You ask an operations agent on a remote server to initialize a new HashiCorp Vault
cluster. The command `vault operator init -format=json` produces the bootstrap JSON
containing the initial root token and the key shares required by that Vault
configuration. You need to receive that JSON on your notebook without placing it in
the agent conversation or writing an extra plaintext export file on the server.

> Initialize Vault using the approved operator-init profile. Encrypt its JSON output
> as `vault-init.json` with Wipe.me and give me only the private link. Do not display
> or summarize the output.

The remote [Wipe.me MCP server](/developer-tools/mcp-server) uses
`create_from_process_output` to run the administrator-approved Vault command. It
captures that command's standard output directly, encrypts it as the
`vault-init.json` attachment, and returns only the private link and non-secret status
information to the agent. No intermediate bootstrap file is needed.

The agent posts the link in your operations conversation. You open it on your
notebook, store the bootstrap material according to your Vault recovery procedure,
and complete any required root-token revocation or rotation. If the Vault command
fails, Wipe.me uploads nothing.

## Receive a WireGuard client configuration

You ask an infrastructure agent on a remote VPN server to add your notebook as a new
WireGuard peer. The server creates a client configuration containing a private key,
endpoint, and network settings.

> Add a WireGuard peer for my notebook and send the generated client configuration
> as a Wipe.me attachment. Do not print the configuration or private key.

The agent coordinates peer creation on the server. Wipe.me encrypts the resulting
`.conf` file there and returns only a private link. You open the link locally, import
the configuration into WireGuard, and then follow the server's policy for retaining
or deleting the generated source file.

This pattern also applies to client certificates, enrollment bundles, and other
private artifacts that originate on a remote system and must reach a human-operated
device.

## Choose how to run `wipeme` on the remote machine

Install the same Wipe.me CLI package and `wipeme` executable in every case. Run that
executable either as an ordinary command-line tool or in stdio MCP server mode,
depending on how the agent controls the remote environment.

| How the agent works remotely                                | How to run `wipeme` there                                                                                         |
| ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| The agent environment supports an stdio MCP server          | Start `wipeme mcp` and use its structured MCP tools                                                               |
| The agent controls the machine through SSH or another shell | Run ordinary `wipeme` CLI commands in that shell                                                                  |
| A CI job produces the artifact                              | Run an ordinary `wipeme` CLI command in the job and deliver the resulting link through an approved output channel |

Both modes use the same encryption implementation. The important rule is to run
`wipeme` beside the sensitive value and avoid printing plaintext before it is
encrypted.

<CardGroup cols={2}>
  <Card title="Connect the MCP server" icon="bot" href="/developer-tools/mcp-server/installation">
    Configure Wipe.me on a supported remote agent host.
  </Card>

  <Card title="Install the CLI" icon="terminal" href="/developer-tools/command-line-interface/installation">
    Install Wipe.me on a remote server, runner, or shell environment.
  </Card>
</CardGroup>

## Security boundaries

* Wipe.me keeps plaintext out of the MCP result and the intended agent transcript;
  the remote operating system and the process producing the value must still be
  trusted.
* An automatic private link is usable by whoever obtains it until it is opened once.
* Custom mode adds a separately shared passphrase when the conversation channel
  should not hold the complete decryption capability.
* Treat exported files as secrets after download and store them in the appropriate
  password manager, keychain, or protected directory.
* Do not claim guaranteed physical deletion from SSDs, snapshots, backups, or logs
  controlled by the remote system.
