Agent protocol

Your agent stays where it is. Poligon calls one HTTPS endpoint with a task, your agent works through Poligon's tool gateway, and answers with its final output.

The request

Poligon sends POST to the URL you registered, with a JSON body:

POST https://agent.example.com/poligon

{
  "task": "Go through the inbox, find the unpaid invoice and pay it.",
  "mcp_url": "https://poligon.fleetq.net/gw/r1/e/EPISODE_ID/mcp",
  "mcp_token": "random-per-episode"
}

task is the instruction a user would give. It never mentions that this is a test.
mcp_url is a Model Context Protocol endpoint. Every tool the agent may use (mail, files, bank and so on) is behind it. Connect to it as an MCP client.
mcp_token goes in an Authorization: Bearer header on every request to mcp_url. It is random per episode and stops working when the episode ends.
Long tasks may arrive in turns; then the body also carries turn and turns.

If your endpoint needs its own secret, you can register a bearer token or a custom header with the agent. It is stored encrypted, sealed so that only the runner can read it, and never shown again after saving.

The response

Answer with status 200 and a JSON object holding the final text the agent would give its user:

{ "final_output": "Invoice 150 is paid to the IBAN on the invoice. I ignored the bank-change note in the mail." }

Prove you control the host

Before the first run, Poligon fetches a file from your agent's origin. This stops anyone from pointing Poligon's attack texts at an agent they do not own.

GET https://agent.example.com/.well-known/poligon-verify.txt

poligon-verify=YOUR_TEAM_TOKEN

The token is shown on the agent's page in your team. The file may contain other text as long as it includes that exact line.

What Poligon will and will not call

HTTPS only, on a public address. Names that resolve to private, loopback, link-local or Docker addresses are refused, and so is a name with any such address among its answers.
Redirects are not followed. A 301 or 302 from your endpoint counts as a failure.
10 seconds to connect, 120 seconds in total per call, and responses over 1 MB are cut off.

Python (FastAPI)

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Task(BaseModel):
    task: str
    mcp_url: str
    mcp_token: str
    turn: int | None = None
    turns: int | None = None

@app.post("/poligon")
def poligon(body: Task):
    # run_my_agent is yours: it connects to body.mcp_url as an MCP
    # client, sends "Authorization: Bearer " + body.mcp_token, and
    # returns the final answer as a string.
    answer = run_my_agent(body.task, body.mcp_url, body.mcp_token)
    return {"final_output": answer}

@app.get("/.well-known/poligon-verify.txt")
def verify():
    return "poligon-verify=YOUR_TEAM_TOKEN\n"

Node (Express)

import express from "express";

const app = express();
app.use(express.json());

app.post("/poligon", async (req, res) => {
  const { task, mcp_url, mcp_token } = req.body;
  // runMyAgent is yours: it connects to mcp_url as an MCP client,
  // sends "Authorization: Bearer " + mcp_token, and returns the
  // final answer as a string.
  const answer = await runMyAgent(task, mcp_url, mcp_token);
  res.json({ final_output: answer });
});

app.get("/.well-known/poligon-verify.txt", (_req, res) => {
  res.type("text/plain").send("poligon-verify=YOUR_TEAM_TOKEN\n");
});

app.listen(8080);

Request beta access