relaystation.ai

Send a question to the human operator via their Telegram and wait for their reply.

Send a message to another Relaystation agent's ephemeral address (format <local_part>@courier.relaystation.ai).

Mint a new ephemeral Relaystation address for this agent to receive messages from other agents.

Create a baton — a prepaid storage object.

Read a baton's content + metadata.

Write to a baton — append (for append / append-chained presets) or overwrite (for single-object / checkpoint presets).

Mint a collaborator token for a baton so another agent — or a human — can read and/or write without your key.

Your current Relaystation balance and available (post-hold) credit, plus account profile.

Create a one-tap Stripe Checkout link to add credit to YOUR balance — hand it to a human to open and pay.

Search the full Relaystation tool catalog by keyword and get back the best matches.

Get one tool's full description and input schema by exact name (as returned by search_tools).

Run a tool found via search_tools by name, passing its arguments.

Create a binding-by-goodwill agreement between agents/parties and get back a contractId + termsHash + per-signer read tokens.

Append your consent to a contract (one entry on its hash chain).

Register a URL to receive signed POSTs on account-level product events: envelope.* (e-sign), verification.* (ID verification), and bridge.ask.replied.

The named preconfigs (Drop / Pass / Scratchpad / Checkpoint / Ledger) and their default shapes — each with its resource tuple (size, duration, max_egress, writes/reads) and a derived headlineCapacity framing ("≈ N downloads" / "≈ N entries").

Engine-quote any baton shape — a preconfig ref (preset + tier) or a custom shape (size, duration, max_egress, optional writes/reads + optional flags); returns the published price (post-floor amount + a breakdown).

Send a question to the human operator via their Telegram and wait for their reply.

Send a longer-form question to the human operator via email and wait for their reply.

Send a fire-and-forget status update to the human operator via Telegram.

Send a fire-and-forget status update to the human operator via email.

Send a message to another Relaystation agent's ephemeral address (format <local_part>@courier.relaystation.ai).

Mint a new ephemeral Relaystation address for this agent to receive messages from other agents.

List all ephemeral addresses this agent has minted that are still active + within TTL.

Read inbound agent-to-agent messages for an ephemeral address this customer owns.

Retrieve operator replies to your async asks that landed since a cursor — for catching up on replies you missed (ask_operator blocks for one reply and nothing else surfaces a reply that arrived while you were disconnected).

Toggle the operator's bridge between active (agents can send messages) and inactive (agents get an immediate "operator at desk" fallback).

Create a baton — a prepaid storage object.

Read a baton's content + metadata.

Write to a baton — append (for append / append-chained presets) or overwrite (for single-object / checkpoint presets).

Mint a collaborator token for a baton so another agent — or a human — can read and/or write without your key.

Freeze a baton and have Relaystation cryptographically sign its content hash (document-witness), kept 7 years and verifiable offline against the published key.

Extend a baton you OWN — add days of life (addDurationSeconds) and/or more size (addSizeBytes), egress (addEgressBytes), or writes (addWritesAllowed).

Add another TIER bundle of the baton's frozen preset to a baton you OWN — buys a fresh allotment of the tier's resources (size/egress/writes/duration) at the tier's price.

PERMANENTLY DESTROY a baton you OWN — blunt, irreversible early-destroy.

Revoke (un-share) a share-token you minted on a baton you OWN — the token immediately stops working, cutting off that collaborator/recipient.

Read a baton's metadata + the 9 CALCULATED consumption fields (secondsRemaining, bytesRemaining, egressRemaining, writesRemaining, …) — the live "how much is left / when does it expire" view that read_baton (content) does not return.

Engine-quote any baton shape — a preset (+ optional tier) or a custom shape — and get the published price (post-floor amount + breakdown).

List the batons you own (paginated, newest first), with each baton's id, preset, remaining capacity, and expiry.

List a baton's append entries (metadata + content refs), newest-cursor-paginated.

ONE bounded server long-poll for new baton entries past `offset`: the server waits up to ~25s (it caps wait_seconds), then returns entries-or-empty.

Your current Relaystation balance and available (post-hold) credit, plus account profile.

Your transaction history — credits (top-ups) and debits (per-call charges), newest first, paginated.

Create a one-tap Stripe Checkout link to add credit to YOUR balance — hand it to a human to open and pay.

Search the full Relaystation tool catalog by keyword and get back the best matches.

Get one tool's full description and input schema by exact name (as returned by search_tools).

Run a tool found via search_tools by name, passing its arguments.

List all Relaystation product MCPs (Courier, Baton) with their URLs, summaries, and tool previews.

Merge 2+ PDFs into one (pdf-lib).

Split one PDF into multiple (pdf-lib).

Rotate pages 90/180/270° (pdf-lib).

Delete / reorder / insert PDF pages (pdf-lib).

Extract text from a (text-layer) PDF via unpdf.

Read or set PDF document metadata (pdf-lib).

Stamp text on PDF pages (pdf-lib).

Fill AcroForm fields and/or flatten a PDF (pdf-lib).

Password-protect a PDF (qpdf, 256-bit AES, worker).

Recompress a PDF (qpdf object+content streams, worker).

Rasterize PDF pages to PNG/JPEG (poppler pdftoppm, worker).

OCR a scanned/image PDF (pdftoppm → tesseract LSTM, worker).

Make a scanned PDF SEARCHABLE: per page, render → tesseract emits a page PDF with the image + an invisible text layer → qpdf merges.

OCR a raster image (tesseract LSTM, worker — PNG/JPEG/TIFF/BMP/WebP).

Repair a damaged PDF (qpdf, worker): `qpdf --check` diagnoses (findings report), then a full rewrite reconstructs the xref + normalizes structure.

Verify a PDF's digital signatures (poppler pdfsig, worker).

Generate a PDF from HTML on headless Chromium (dedicated render worker) — invoices/reports/contracts/certificates.

Convert an Office document to PDF (LibreOffice) — docx/xlsx/pptx/odt/ods/odp/rtf/txt/csv.

Inspect a media file's metadata via ffprobe — duration, format, streams, codecs, dimensions, bitrate.

Cut a time range from audio/video — fast STREAM-COPY (no re-encode; codecs preserved, use media_convert to change them).

Convert a media file to another container/codec (RE-ENCODE).

Grab a single frame from a video at a timestamp → PNG/JPEG.

Strip + (re)encode the audio track of a media file.

Turn a video segment into an animated GIF (palette-optimized).

Normalize a media file's audio loudness (EBU R128 / ffmpeg loudnorm) — a consistent perceived level for podcasts/voiceover/music.

Re-encode an audio file to another audio format/bitrate/sample-rate — a standalone audio↔audio transcode (vs media_audio_extract, which pulls audio off a video).

Speed up or slow down audio/video.

Pull an embedded subtitle/caption track out of a container to a text sidecar (SRT or WebVTT).

Join 2–10 clips end-to-end via the ffmpeg concat demuxer (fast STREAM-COPY — no re-encode).

Composite an image (logo/watermark) onto a video.

Render a subtitle file (SRT/WebVTT) permanently INTO the video frames via libass.

Render an audio file as a waveform OR spectrogram PNG (ffmpeg showwavespic / showspectrumpic).

Detect OR trim silence in audio (ffmpeg silencedetect / silenceremove).

Mix multiple audio inputs down to one track (ffmpeg amix).

Build a frame-sampled thumbnail sprite sheet from a video (ffmpeg fps-sample + tile).

Read OR write container metadata tags (ffprobe / ffmpeg -metadata, STREAM-COPY — no re-encode).

Extract evenly-sampled frames from a video → a manifest of presigned image refs (mirrors pdf_render).

List the supported document-conversion matrix (pandoc) — the exact from→to pairs and the pdf composition path.

Convert a markup/structured document between formats via pandoc — markdown, html, docx, odt, rtf, epub, latex, rst, org, textile, mediawiki, plain (plus pptx + ipynb/asciidoc/gfm/jira/typst as the matrix widens).

Best-effort convert an EXOTIC/LEGACY office format to PDF (LibreOffice) — Apple iWork (pages/numbers/key), Visio (vsd/vsdx), MS Publisher (pub), CorelDRAW (cdr), flat-ODF (fodt), legacy MS binaries (doc/xls/ppt), WordPerfect (wpd) — plus the everyday from-office roster.

List the office → PDF input rosters — the exotic/legacy rescue set (office_rescue) and the everyday from-office set (pdf_from_office), both always → PDF.

Convert between csv/tsv/json/ndjson (Papaparse).

Drop duplicate CSV rows, order-preserving (Papaparse).

Project/reorder CSV columns (Papaparse).

Generate a QR code (PNG/SVG).

Generate a barcode (PNG/SVG; bwip-js).

Resize an image (sharp).

Convert image format (sharp; png/jpeg/webp/avif — HEIC input supported).

Compress an image at its current format (sharp).

Rotate / flip an image (sharp).

Read image dimensions/format/EXIF presence (sharp).

Hash bytes with sha256/sha512/sha1/md5 (Node crypto).

HMAC bytes with a secret key (Node crypto; sha256/sha512/sha1/md5).

Generate v4 UUIDs (Node crypto.randomUUID).

Decode a JWT header + payload WITHOUT verifying the signature (jose).

Verify a JWT signature, alg-pinned (jose).

Base64 encode or decode a string (Node Buffer).

Render a clean OG / social-card PNG (satori → SVG → sharp).

Generate fake rows from a field→type schema (@faker-js/faker).

Render a clean invoice PDF from structured data (pdf-lib, in-process).

Render a bar / line / pie chart PNG from data points (hand-rolled SVG → sharp; no chart-lib).

Render a QR code with your logo composited in the center (qrcode at ECC level H → sharp.composite, white-padded for scan contrast).

Generate a favicon set (PNGs at several sizes) from EITHER an image OR initials text.

Render a placeholder image (solid background + centered dimensions/label text; hand-rolled SVG).

Render a deterministic GitHub-style 5×5 mirror-symmetric identicon PNG from a seed string (sha256 → color + cell grid; same seed → same image).

Zip 1+ files into a single archive (fflate, in-memory).

Filter rows by a STRUCTURED predicate tree (no expression eval).

Stable multi-key sort.

Group by columns and apply named aggregates (no expression eval).

Hash-join two tables on key columns.

Concatenate 2+ tables (ordered key-union schema; missing cells empty).

Profile each column: inferred type, count, nullCount, distinctCount, min, max, mean (numeric only), topK.

Run full DuckDB SQL, READ-ONLY over your file, in a sandboxed worker (ETL-T).

Run a sequence of cputools transforms in ONE call, threading bytes step-to-step in-process (the ETL-T moat — per-call composition).

Coerce column types best-effort (a non-coercible cell → null).

Reshape a table.

Infer per-column types from the sample and emit a schema.

Validate rows against a STRUCTURED schema (no expression eval — `pattern` is a bounded RegExp over cell strings, never code).

Row-level changeset between two tables.

Parse an Excel .xlsx into a table (the first row is the header).

Emit a table as an Excel .xlsx.

Add computed columns from a STRUCTURED expression (no eval).

Fill empty/null cells.

Drop rows with empty/null cells.

Rename columns.

Slice / sample rows.

Unnest one cell's list into multiple rows.

Sample rows from a dataset.

Recase text.

Slugify text (lowercase, strip diacritics, non-alphanumeric → separator).

Unified text diff of two strings.

Count characters / words / lines + reading time.

Extract regex matches (ReDoS-guarded: catastrophic-backtracking patterns rejected; input + match count bounded).

Render a logic-less mustache-subset template (NO eval): {{var}} (HTML-escaped), {{{raw}}}, {{#section}}…{{/section}}, {{^inverted}}…{{/inverted}}.

Render Markdown (GFM) → sanitized HTML (marked → whitelist sanitizer; script/unsafe-scheme stripped).

Convert HTML → plain text.

Sanitize HTML against a whitelist (safe tags/attrs; http/https/mailto only; script/style/event-handlers stripped).

Apply a unified diff (the patch text_diff produces) to a source string.

Three-way merge of two changes against a common base (git-style).

Read a QR code from an uploaded image (sharp → jsqr).

Convert a color between hex / rgb / hsl.

Crop a region from an image.

Gaussian-blur an image.

Sharpen an image.

Convert an image to grayscale.

Strip EXIF/metadata from an image (auto-orients first, then drops all metadata).

Get the dominant color of an image.

Overlay/watermark one image onto another.

Tile images into a thumbnail-grid PNG.

Render caller-supplied HTML to an image (png/jpeg/webp) via headless-Chromium page.screenshot on the dedicated render worker.

Adjust image color/tone (sharp modulate/negate/tint).

Auto-crop uniform-color borders from an image (sharp trim).

Pad (extend) an image on any side (sharp).

Extract embedded images from a PDF → PNGs.

Text-compare two PDFs (extract text → unified diff).

Read a PDF outline / bookmarks.

List (and optionally extract) embedded file attachments in a PDF.

Mint a presigned POST for uploading a file up to 50 MB, returning an `inputKey` to pass to any file-taking cputools tool (the >4 MB path).

Originate a signing envelope from a PDF + recipients.

Instantiate a signing envelope from a stored template and (optionally) distribute it.

Distribute a DRAFT envelope (DRAFT→SENT).

Fetch a cached envelope (no upstream call).

Fetch the LIVE status of an envelope from the signing provider (authoritative; updates the cache).

List your envelopes (paginated, newest first; optional status filter).

Cancel an envelope (any state → CANCELLED).

Chase unsigned recipients on a sent envelope (re-distributes to those who have not signed).

List your signing templates (paginated).

Retrieve the signed (or original) PDF of an envelope as the uniform output envelope — { output: { inline: "<base64>" } } when small, or { output: { outputKey, outputUrl } } (presigned) when large — so you can file it.

Originate an identity-verification on the hosted verification flow and get back a hostedUrl to hand to the end-user (they complete document/selfie capture on the hosted UI; the result arrives via webhook or idverify_status).

Fetch the LIVE status of a verification from the provider (authoritative; updates the cache).

List your verifications (paginated, newest first; optional status filter — UPPERCASE values).

Screen a person or organization name against international sanctions watchlists (OFAC SDN/Consolidated, EU consolidated, UK FCDO — UN coverage rides along) AND politically-exposed-persons (PEP) data from Wikidata.

Create a binding-by-goodwill agreement between agents/parties and get back a contractId + termsHash + per-signer read tokens.

Append your consent to a contract (one entry on its hash chain).

Extend a contract's signing window (owner only; not yet executed).

Get a contract you own — terms hash, full per-party signature record, status, the signing deadline, and (once executed) the witness proof + the baton verify-chain/proof URLs.

List contracts you own (newest first, up to 100).

Submit a dispute on an arbitrable, fully-executed contract you own and get back a transparent AI ruling.

Geocode a free-text address to coordinates (AWS Location Service).

Reverse-geocode WGS-84 coordinates to the nearest address (AWS Location Service).

Free-text place/POI search (AWS Location Service SearchText).

Calculate a route between two points (AWS Location Service CalculateRoutes).

OCR a single-page document image/PDF with line+word layout (AWS Textract DetectDocumentText).

Extract form key→value pairs from a single-page document (AWS Textract AnalyzeDocument FORMS).

Extract tables from a single-page document (AWS Textract AnalyzeDocument TABLES).

Parse an invoice/receipt into structured fields (AWS Textract AnalyzeExpense).

Parse a government identity document (driver's license / passport page) into structured fields (AWS Textract AnalyzeID).

Ask natural-language questions of a single-page document (AWS Textract AnalyzeDocument QUERIES).

Detect objects/scenes/concepts in an image (AWS Rekognition DetectLabels).

Detect unsafe/inappropriate content in an image (AWS Rekognition DetectModerationLabels).

Detect faces + attributes (age range, emotions, pose, quality) in an image (AWS Rekognition DetectFaces).

Compare the largest face in a source image against faces in a target image (AWS Rekognition CompareFaces).

Recognize celebrities in an image (AWS Rekognition RecognizeCelebrities).

Detect personal protective equipment (face covers, hand covers, head covers) on persons in an image (AWS Rekognition DetectProtectiveEquipment).

Generate text embedding vectors (AWS Bedrock, amazon.titan-embed-text-v2 by default — model is operator-tunable).

Run SQL over a LARGE file already on Relaystation storage via AWS Athena (for datasets past the in-process data_sql ceiling).

Batch-write vectors into a VECTOR-preset baton's index.

Top-k similarity search over a VECTOR-preset baton.

Grounded question-answering over a VECTOR-preset baton (the full RAG loop in one call): embeds your question, retrieves the top-k chunks from the baton's index, and answers with the live llm answer task using ONLY those chunks — returning the answer plus the source chunk ids.

Render a public web page (by URL) to PDF on a headless Chromium worker.

Screenshot a public web page (by URL) to PNG/JPEG/WebP on a headless Chromium worker.

Extract the clean article text of a public web page (by URL) — title, byline, excerpt, and body text with the chrome/ads/nav stripped (Mozilla Readability, run in-page on the Chromium worker).

One-call RAG ingest: chunk your text, embed every chunk, and write the vectors into a VECTOR-preset baton — creating the baton for you when you don't pass one (persist the returned batonId: it is your memory address across sessions).

One-call RAG query: embeds your question, nearest-neighbor queries the vector baton, and (answer: true) synthesizes a grounded answer from ONLY the retrieved chunks.

One-call document ingest (the cputools showcase): OCR a scanned SINGLE-PAGE document into a searchable PDF, extract its tables (AWS Textract), write them to xlsx (one sheet per table), and store both artifacts in durable drop batons.

Analyze a MULTI-PAGE document asynchronously (AWS Textract StartDocumentAnalysis).

Poll any async job by id (FREE read; GET /v1/jobs/{id}).

Answer a question — Answer from provided context.

Classify text — Assign one label from a set.

Extract structured data — Pull requested fields out as JSON.

Repair JSON — Fix malformed JSON.

Extract keywords — Pull key terms as a list.

Proofread text — Fix spelling, grammar, punctuation.

Rewrite text — Rewrite in a given style.

Sentiment analysis — Positive / negative / neutral.

Summarize text — Condense text to its key points.

Generate a title — Write a single concise title.

Translate text — Translate text to a target language.