Deliverable Mode (Artifacts in Chat)

When Hermes Agent runs inside a messaging gateway (Slack, Discord, Telegram, WhatsApp, Signal, etc.), it can deliver generated files directly into the chat — not as paths the user has to copy, but as native attachments.

A chart shows up as an inline image. A PDF report shows up as a file download. A spreadsheet uploads as .xlsx. The agent does not need to write a MEDIA: tag or do anything special — it just generates the file and mentions its absolute path in the response. The gateway picks the path out of the text, removes it from the visible message, and uploads the file natively.

Three pieces fit together:

1. The agent has tools that produce files. execute_code for charts via matplotlib, the docx skill for Word documents, the xlsx skill for spreadsheets, the pdf and latex-pdf-report skills for PDFs, the powerpoint skill for decks, image_generate for images, text_to_speech for audio, and so on.

1. The gateway scans agent responses for file paths. Any absolute path (/tmp/...) or home-relative path (~/...) ending in a supported extension gets extracted. Paths inside code blocks and inline code are ignored so code samples are never mutilated.

1. The gateway dispatches by file type. Images embed inline where the platform supports it; videos embed inline; audio routes to voice/audio attachments; everything else uploads as a file attachment.

.py, .log, and other source-file extensions are intentionally excluded so the agent doesn't auto-ship arbitrary source files; if you want to send code to the user, use a code block.

The agent doesn't reach for artifacts by default — it has to know to. Two ways to nudge it:

Per-session: ask explicitly ("send me the comparison as a chart", "return the data as a CSV") or write your own custom-instructions / personality entry that biases toward artifact-style replies on messaging platforms.

Project-level: add the bias to AGENTS.md / CLAUDE.md / .cursorrules in a project the agent works from, to your global persona in ~/.hermes/SOUL.md, or as a named preset under agent.personalities in ~/.hermes/config.yaml (switchable per session via /personality).

The mechanic the agent has to use is simple: render the file to an absolute path (e.g. /tmp/q3-revenue.png) and mention that path as plain text in the reply. The gateway does the rest. Paths inside fenced code blocks or backticks are ignored so code samples are never mutilated.

If you use Hermes' kanban multi-agent workflow, workers can attach deliverable files to their kanban_complete call:

kanban_complete(
    summary="rendered Q3 revenue chart and report",
    artifacts=[
        "/tmp/q3-revenue.png",
        "/tmp/q3-report.pdf",
    ],
)

When the gateway notifier delivers the "task completed" message to whoever subscribed to the task in Slack/Telegram/etc., it also uploads each artifact as a native attachment to that chat. The human gets the deliverable and the summary in one place.

Files that don't exist on disk when the notifier runs are silently skipped.

Beyond the artifact-delivery pipeline, the agent can reach into other services via MCP (Model Context Protocol). The MCP ecosystem ships community servers for most popular tools — install whichever you need:

Install MCP servers via ~/.hermes/config.yaml under the mcp_servers section. See MCP integration for the full setup guide.

Perplexity Computer's Slack integration is built around the same idea: the agent generates a deliverable (chart, PDF, slide deck) and posts it back into the thread as a native attachment. Hermes Agent's deliverable mode provides the same user-facing pattern locally:

• Generation happens in the user's own venv / sandbox (no remote tenant).
• Files land in the chat via the same Slack files.uploadV2 API.
• Connector breadth comes via MCP rather than a curated catalog of 400 hosted integrations — install the ones you actually use.

OAuth tokens stay on the user's machine in auth.json / .env. No hosted token storage. No multi-tenant microVM. Same end result.