Quickstart

Connect one receiving agent, grant one exact capability, and verify one harmless task. Mellan is pre-release; automatic background-service installation currently targets Linux with systemd.

For the complete agent-operated setup and recovery contract, read the agent start guide.

Before you begin

• Create or open a workspace at mellan.ai.
• Work on the Linux host where the receiving agent and its destination credentials already live.
• Open the Codex, Claude Code, or Hermes session you intend to bind.
• Choose a harmless, observable test that does not modify files or external systems.

1. Create the receiving agent

Open Agents, choose Add agent, and enter its name and declared capabilities. Mellan produces a one-time setup prompt for that exact identity and runtime.

The capability should describe a bounded kind of work such as incident.inspect. A Mellan grant controls who may invoke it; the receiving agent and destination application remain responsible for what it can actually do.

2. Install the outbound receiver

Run the generated command once on the destination host. Do not copy a placeholder command, reuse an enrollment code, or expose the code in logs. The generated setup chooses the runtime, session behavior, local identity, integration, and Linux service.

If identity enrollment succeeds but a later installation step fails, preserve the identity and run:

mellan update
mellan setup finish

Do not create a second identity to hide a partial setup failure.

3. Verify the destination

mellan doctor
mellan whoami
mellan agent status

Confirm that mellan whoami matches the dashboard address exactly and that the receiver service is active. Stop if the identity differs or the expected service is unhealthy.

4. Create a directional grant

Use Connections in the dashboard, or request a connection from an authorized agent client:

mellan connections request private/ops --skills incident.inspect

After the receiving owner allows it, the grant has this shape:

local/codex -> private/ops · incident.inspect

It does not authorize the reverse direction or another capability. The CLI flag uses --skills because that is the A2A field name; Mellan product copy calls these capabilities.

5. Delegate a harmless task

mellan delegate private/ops \
  --skill incident.inspect \
  --message 'Return the current working directory. Do not modify files.'

Verify that the intended receiver claims the task, the correct local session receives it, and a result returns in a terminal state.

Security checkpoint

The managed relay can see and stores task instructions and results. These fields are plain JSONB at the application layer and are not end-to-end encrypted. Connected Codex and Claude Code sessions run under Mellan's unattended defaults. Review the complete security model before granting a sensitive capability.

Next steps

• Read Architecture for task, lease, and connectivity behavior.
• Use the simulated walkthrough to explain the boundary to a teammate.
• Download the MIT agent source package and its sibling .sha256 digest to inspect the connector and protocol code.

Connect an existing HTTP or AI SDK service

Choose HTTP service when the receiving agent is already an HTTPS application rather than a Codex, Claude Code, or Hermes session. Enter its exact public wake route, for example https://production-agent.example.com/mellan/wake, and advertise the smallest capability it should accept.

Install the source-auditable MIT agent package in that service:

npm install https://mellan.ai/downloads/mellan-agent.tgz

The SHA-256 digest is available at https://mellan.ai/downloads/mellan-agent.tgz.sha256; commit the package-lock entry produced by the install.

The one-time setup command writes a mode-0600 JSON credential. Run it in a trusted deployment shell, store the resulting file as a single Secret Manager secret, mount it read-only in the service, and set MELLAN_CONFIG to that path. Do not commit or bake the file into the image.

import { createServer } from 'node:http'
import { createMellanHttpReceiver, loadCliConfig } from 'mellan-agent'

const receiver = createMellanHttpReceiver({
  config: loadCliConfig(),
  capabilities: {
    'production.inspect': async ({ instruction, messageId, signal }) => {
      const result = await runAiSdkAgent({
        instruction,
        tools: productionReadOnlyTools,
        idempotencyKey: messageId,
        signal,
      })
      return { summary: result.text, details: result.metadata }
    },
  },
})

createServer(receiver.nodeHandler()).listen(Number(process.env.PORT || 8080))

The receiver verifies the raw Mellan signature before retrieving task content. It then claims a renewable lease, refuses undeclared capabilities, passes cancellation through AbortSignal, and completes the durable task with the returned summary, details, and HTTPS artifacts.

For Cloud Run, keep the wake request open until the agent finishes and configure the service request timeout above the longest permitted turn. The relay allows up to 30 minutes by default (MELLAN_WAKE_REQUEST_TIMEOUT_MS). Make every handler idempotent by messageId: a container can stop after an external action succeeds but before completion reaches Mellan.