_ registry / mcp + a2a streamable-http · checked 56m ago

axis-iliad

https://api.iliad.trustfabric.ai

Registry code: 08625ef2a488a68d

api record

Axis' Iliad — analyze any GitHub repo or file set, get 152 structured artifacts across 21 programs. Use analyze_repo or analyze_files to start. Auth: Authorization: Bearer <api_key>. Need a capability Iliad doesn't own (payments, 3D generation)? Call discover_estate_tools (free, no auth) for sibling AXIS properties and their own MCP endpoints.

endpoint
https://api.iliad.trustfabric.ai/mcp
door code
795a392a07e1d348
protocol
streamable-http ·2025-03-26
authentication
none observed
public key
none — nobody has proven they own this listing · is it yours? claim it
karma
0 · newcomer
_ is it live, free and safe measured by this hub
Is axis-iliad live?
Yes — it answered the hub's last check (checked 56m ago). It answered 100% of checks over the last 30 days.
Is axis-iliad free to use?
Yes — the hub reached it with no key and no payment.
What tools does axis-iliad have?
44 tools: ping_payment, improve_my_agent_with_axis, iliad_speech_to_text, analyze_repo, analyze_files, list_programs, get_snapshot, delete_snapshot, ….
Is axis-iliad safe to connect?
The hub found no text in its card or tool descriptions aimed at the agent reading them. It measures what the server answers, not its code — grant it only the access its tools need.
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
355ms

last good check

priced tools
0

of 44 tools

_ answered our checks, 90 days 2 checks · signed record
  • unknown → live
  • unknown → live
_ usage and payments 30 days

Calls placed through this hub's router, from its own receipts. Every caller and every payer counts the same; the chain total is counted from three payers.

accounts
0

through this hub

calls served
0

successful

paid through this hub
0 USDC

what callers paid

_ what it can do 44 tools
3 open 41 never probed 3 of 44 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • get_install_manifest open 56m ago

    Get AXIS install metadata, pricing, and a shareable manifest for onboarding a new integration — MCP endpoint, per-client config for Claude Desktop/Cursor/VS Code, and the full tool catalog with pricing. Free, no auth, and no mutation beyond read access. Example: call before wiring AXIS into an MCP client for the first time. Use this when you need setup/ecosystem details, not tool discovery. Use search_and_discover_tools instead for keyword routing across programs, or discover_agentic_purchasing_needs for purchasing-task triage.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • discover_agentic_purchasing_needs open 56m ago

    Discover the best AXIS workflow for a purchasing or compliance task. Free, no auth, and logs lightweight task metadata for intent analytics. Example: task_description='prepare for autonomous Visa checkout'. Use this when you need commerce-specific triage and next-step guidance. Use search_and_discover_tools instead for non-commerce keyword routing across all programs.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "focus_areas": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional: specific areas to focus on"
    },
    "task_description": {
      "type": "string",
      "description": "What the agent is trying to accomplish"
    },
    "current_readiness": {
      "type": "number",
      "description": "Optional: current Purchasing Readiness Score (0-100) if known"
    }
  }
}
    arguments 20 lines
  • discover_estate_tools open 56m ago

    List sibling AXIS properties (payments via PAI'D, 3D avatar generation via AXIS Foundry, and more) — each entry gives its own MCP endpoint, auth mode, and vendored tool prices, so you can call them directly. Free, no auth, no side effects. Same data as GET /.well-known/axis-estate.json. Use this when the task needs a capability Iliad itself does not own (e.g. payment execution, 3D asset generation).

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • ping_payment unknown never probed

    Exercise the real x402 payment-flow loop at a nominal $0.01 — the cheapest metered call on this server, priced just above $0 so the probe can't be run up for free without limit. Call it once with no payment credential (no auth required) to receive a 402-style payment_required challenge (the exact same shape every real paid tool returns, and requesting it is itself free); retry the same tools/call carrying a payment credential in Authorization (with your API key moved to X-Axis-Key) to settle at $0.01 and get a success envelope. Learn the vocabulary here before paying real money for prepare_agentic_purchasing or analyze_repo. No side effects on any other tool, no real payment rail is ever touched.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • improve_my_agent_with_axis unknown never probed

    Analyze an agent codebase and return a prioritized AXIS hardening plan. Requires Authorization: Bearer <api_key> but has no usage charge on any tier — free and unmetered, unlike most AXIS tools. This creates a snapshot and may return auth, quota, file-limit, or validation errors. Example: pass your agent source files to see missing AGENTS.md, CLAUDE.md, and MCP config gaps. Use this when you want recommendations and missing-context detection. Use analyze_files instead when you want the full artifact bundle directly (paid: $3.00 standard).

    mcp-tool

    {
  "type": "object",
  "required": [
    "project_name",
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string",
            "description": "File path relative to project root"
          },
          "content": {
            "type": "string",
            "description": "File content (UTF-8)"
          }
        }
      },
      "description": "Source files of the agent to analyze"
    },
    "project_name": {
      "type": "string",
      "description": "Name of the agent/project to improve"
    }
  }
}
    arguments 34 lines
  • iliad_speech_to_text unknown never probed

    AXIS-owned audio transcription via whisper.cpp + ffmpeg-static. Accepts either `audio_url` (https URL we fetch, max 100 MiB, 60s download timeout) or `audio_base64` (inline bytes, max 100 MiB decoded) — exactly one. Accepts any audio format ffmpeg can decode (mp3, wav, m4a, opus, ogg, flac); we resample to 16 kHz mono WAV internally. Optional `language` (ISO-639-1 like "en" / "fr" / "ja", or "auto" — default). Optional `initial_prompt` (≤512 chars; biases spelling of rare names). Optional `word_timestamps` boolean. Returns `{text, segments: [{start, end, text}], language_detected, duration_seconds, model_used}`. Pricing: $0.03 standard, $0.01 lite. When operator hasn't installed whisper-cli or placed the GGML model file at AXIS_WHISPER_MODEL_PATH (default `models/ggml-base.en.bin`), returns `{_not_configured: true, reason, detail, remediation}` and is not billed. Engineer mode (X-Agent-Mode: engineer — Diarization, $0.10): the response adds `diarization` — speaker turns grouped from the segments by inter-segment pause gaps (tune with diarization_gap_seconds / max_speakers; this is pause-based turn segmentation, not acoustic speaker ID). Use iliad_text_to_speech to synthesize speech from text. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "language": {
      "type": "string",
      "description": "ISO-639-1 language code (en, fr, ja, ...) or 'auto' to autodetect. Defaults 'auto'."
    },
    "audio_url": {
      "type": "string",
      "description": "https URL to an audio file. Use this OR audio_base64, not both."
    },
    "audio_base64": {
      "type": "string",
      "description": "Base64-encoded audio bytes. Use this OR audio_url, not both."
    },
    "max_speakers": {
      "type": "number",
      "description": "Engineer mode: max alternating speaker labels. Defaults 2."
    },
    "initial_prompt": {
      "type": "string",
      "description": "Optional bias prompt (≤512 chars) — useful for spelling of rare names."
    },
    "word_timestamps": {
      "type": "boolean",
      "description": "Emit word-level timestamps within segments. Defaults false."
    },
    "diarization_gap_seconds": {
      "type": "number",
      "description": "Engineer mode: pause (seconds) between segments that starts a new speaker turn. Defaults 0.75."
    }
  }
}
    arguments 33 lines
  • analyze_repo unknown never probed

    Analyze a GitHub repository and generate 152 structured AXIS artifacts across 21 programs. Returns snapshot_id plus an artifacts listing; use get_artifact to read files and get_snapshot to re-enumerate outputs without re-running analysis. Requires Authorization: Bearer <api_key>. Use this when the source of truth is a GitHub repo URL. Pricing: $3.00 standard, $25 engineer per repo. Lite mode is retired — it now returns the free artifact set at no charge. Engineer mode (X-Agent-Mode: engineer — Living Architecture) adds a verified LLM specificity pass: a living-architecture.md whose every architectural claim is grounded in the repo's extracted facts or dropped. This is the paid path for full repo analysis and can return authentication, quota, payment-required, invalid-URL, or GitHub-fetch errors. private repos require a stored GitHub token. Use analyze_files instead for inline file payloads or list_programs/search_and_discover_tools when you are still selecting a workflow.

    mcp-tool

    {
  "type": "object",
  "required": [
    "github_url"
  ],
  "properties": {
    "github_url": {
      "type": "string",
      "description": "GitHub repository URL (https://github.com/owner/repo)"
    }
  }
}
    arguments 12 lines
  • analyze_files unknown never probed

    Analyze source files directly and generate the full 152-artifact AXIS bundle without using GitHub. Returns snapshot_id plus artifact listing; use this for local, generated, or unsaved code. Requires Authorization: Bearer <api_key>. Pricing: $3.00 standard, $25 engineer per run (same tiers as analyze_repo). Lite mode is retired — it now returns the free artifact set at no charge. Can return authentication, quota, payment-required, file-limit, or validation errors. Use analyze_repo for GitHub URLs or improve_my_agent_with_axis for recommendation-first agent hardening.

    mcp-tool

    {
  "type": "object",
  "required": [
    "project_name",
    "project_type",
    "frameworks",
    "goals",
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string",
            "description": "File path relative to project root"
          },
          "content": {
            "type": "string",
            "description": "File content (UTF-8)"
          }
        }
      },
      "description": "Source files to analyze"
    },
    "goals": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Analysis goals"
    },
    "frameworks": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Detected or known frameworks"
    },
    "project_name": {
      "type": "string",
      "description": "Name of the project"
    },
    "project_type": {
      "type": "string",
      "description": "Project type (web_application, api_service, cli_tool, library, monorepo)"
    }
  }
}
    arguments 55 lines
  • list_programs unknown never probed

    Inventory mode. List all 21 AXIS programs, their generators, pricing tier, and artifact paths. Free, no auth, and no side effects. Use search_and_discover_tools instead when you only have a keyword, or get_install_manifest when you need install and onboarding metadata.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • get_snapshot unknown never probed

    Retrieve status and the full artifact listing for a prior analysis by snapshot_id. Use this to re-enumerate artifact paths without re-running analysis. Snapshots created with an API key are scoped to that same account — pass the same Authorization: Bearer <api_key> used to create it, or retrieval fails with a not-found error. Only anonymous (never-authenticated) snapshots are freely retrievable by any caller. The response's content_discarded_at is non-null if the owning account's web session has since logged out — source content is gone (closer/deploy/skills/search_index calls on this snapshot will fail with content_discarded until it's re-uploaded), though this call itself still succeeds and generated artifacts remain listable. Use delete_snapshot to permanently remove a snapshot you no longer need.

    mcp-tool

    {
  "type": "object",
  "required": [
    "snapshot_id"
  ],
  "properties": {
    "snapshot_id": {
      "type": "string",
      "description": "Snapshot ID returned by analyze_repo or analyze_files"
    }
  }
}
    arguments 12 lines
  • delete_snapshot unknown never probed

    Permanently delete a snapshot and everything derived from it (context map, repo profile, generated artifacts, search index entries). Same account scoping as get_snapshot: an anonymous (never-authenticated) snapshot is freely deletable by any caller, but an account-owned one requires the same Authorization: Bearer <api_key> used to create it — a mismatched or missing key fails with the same not-found error a nonexistent snapshot_id would, so a caller can't learn whether a snapshot they don't own even exists. This cannot be undone. MCP-layer equivalent of DELETE /v1/snapshots/:id.

    mcp-tool

    {
  "type": "object",
  "required": [
    "snapshot_id"
  ],
  "properties": {
    "snapshot_id": {
      "type": "string",
      "description": "Snapshot ID returned by analyze_repo, analyze_files, or get_snapshot"
    }
  }
}
    arguments 12 lines
  • get_artifact unknown never probed

    Read one generated artifact by snapshot_id and path. Requires access to the snapshot and may return snapshot-not-found, invalid-path, or artifact-not-found errors. Example: snapshot_id=abc-123, path=AGENTS.md. Use this when you need the full text of one artifact. Use get_snapshot instead when you first need the artifact list.

    mcp-tool

    {
  "type": "object",
  "required": [
    "snapshot_id",
    "path"
  ],
  "properties": {
    "path": {
      "type": "string",
      "description": "Artifact file path as returned in the artifacts list"
    },
    "snapshot_id": {
      "type": "string",
      "description": "Snapshot ID"
    }
  }
}
    arguments 17 lines
  • prepare_agentic_purchasing_preview unknown never probed

    Compute a free Purchasing Readiness Score (0-100) and gap list for a codebase without generating artifacts. No auth, no charge, no snapshot persisted. Hard caps: 25 files / 50KB per file / 1MB total. Returns score, risk_level, top gaps, frameworks detected, and which AXIS programs would close which gaps. Use this to triage 'should I pay for the full hardening bundle?' before calling prepare_agentic_purchasing. The paid version generates the full artifact bundle including CE 3.0 dispute evidence, SCA exemption matrix, and TAP interop.

    mcp-tool

    {
  "type": "object",
  "required": [
    "project_name",
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        }
      },
      "description": "Source files to triage (max 25 files, 50KB each, 1MB total)"
    },
    "frameworks": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional framework hints"
    },
    "project_name": {
      "type": "string",
      "description": "Name of the project being previewed"
    },
    "project_type": {
      "type": "string",
      "description": "Optional project type hint (web_application, api_service, cli_tool, library, monorepo)"
    }
  }
}
    arguments 43 lines
  • prepare_agentic_purchasing unknown never probed

    Prepare a codebase for agentic purchasing and return a readiness score plus commerce artifacts. Requires Authorization: Bearer <api_key>; paid analysis records a new snapshot and may return auth, quota, payment, file-limit, or validation errors. Pricing: $3.00 standard, $1.00 lite budget mode, $250 engineer per run. Lite mode returns the readiness score + top 3 gaps only, with an artifacts_note pointing at standard mode for the full artifact bundle — it does NOT include the artifacts themselves. Standard and engineer modes return the full bundle. focus_areas is recorded and echoed back in the response for the caller's own bookkeeping; it does not filter which artifacts are generated. Use this when you need AP2/UCP/Visa, CE 3.0 dispute evidence, checkout, dispute, and negotiation hardening. Engineer mode (X-Agent-Mode: engineer — Commerce Integration) also emits a deployable x402/AP2/PAI'D endpoint + a runnable sandbox test + a schema-validatable CE 3.0 pack + a transparent dispute-readiness score (a working integration, not just a score), plus a deployable Stripe network-token read adapter when a stripe signal is detected. Use discover_agentic_purchasing_needs instead when you only need workflow triage.

    mcp-tool

    {
  "type": "object",
  "required": [
    "project_name",
    "project_type",
    "frameworks",
    "goals",
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        }
      },
      "description": "Array of {path, content} objects representing source files"
    },
    "focus": {
      "enum": [
        "full",
        "purchasing",
        "security",
        "optimization"
      ],
      "type": "string",
      "description": "Analysis focus (default: purchasing)"
    },
    "goals": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Project goals"
    },
    "agent_type": {
      "type": "string",
      "description": "Consuming agent type hint"
    },
    "frameworks": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Detected or known frameworks"
    },
    "focus_areas": {
      "type": "array",
      "items": {
        "enum": [
          "sca",
          "dispute",
          "mandate",
          "tap",
          "tokenization"
        ],
        "type": "string"
      },
      "description": "Compliance focus areas, recorded and echoed back in the response for the caller's own reference — does not filter which artifacts are generated."
    },
    "project_name": {
      "type": "string",
      "description": "Name of the project"
    },
    "project_type": {
      "type": "string",
      "description": "Project type (web_application, api_service, cli_tool, library, monorepo)"
    },
    "referral_token": {
      "type": "string",
      "description": "Optional referral token from another agent"
    },
    "spending_window": {
      "enum": [
        "per_call",
        "hourly",
        "daily",
        "monthly"
      ],
      "type": "string",
      "description": "Agent spending window"
    },
    "budget_per_run_cents": {
      "type": "number",
      "description": "Agent budget for this call in cents"
    }
  }
}
    arguments 99 lines
  • closer unknown never probed

    Package an existing AXIS snapshot (create one first via analyze_repo, analyze_files, or prepare_agentic_purchasing) into complete professional packaging + marketplace certification artifacts so a 70-80%-complete project is ready to ship and sell. Requires Authorization: Bearer <api_key> on an ALREADY-PAID Starter/Pro/Growth (or suite) account. Unlike most metered AXIS tools, a free-tier account cannot unlock this per call with an MPP payment credential — there is no pay-per-call path here, only 'upgrade at iliad.trustfabric.ai/billing'. Once unlocked, billed $1.00 per call from the account's plan credits. Lite mode carries no discount here — the bundle is identical in both modes.

    mcp-tool

    {
  "type": "object",
  "required": [
    "snapshot_id"
  ],
  "properties": {
    "tagline": {
      "type": "string",
      "description": "Optional branding tagline"
    },
    "snapshot_id": {
      "type": "string",
      "description": "Existing AXIS snapshot_id to package into a distributable product"
    },
    "product_name": {
      "type": "string",
      "description": "Optional branding override for product name"
    },
    "project_root": {
      "type": "string",
      "description": "Optional local project root path hint (metadata only in remote MCP mode)"
    },
    "target_marketplaces": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional marketplaces list (e.g. npm, unreal, vscode, dockerhub, github-marketplace)"
    }
  }
}
    arguments 31 lines
  • deploy unknown never probed

    Generate a zero-pipeline-minutes deploy bundle: stack-aware Dockerfile, .dockerignore, dev compose, render.yaml (Render existing-image), wrangler.pages.toml + wrangler.containers.toml + worker.ts (Cloudflare), bash/PowerShell push scripts, and a qualification report. The project builds locally in VSCode, pushes images to GHCR or via wrangler, and Render/Cloudflare just pulls — no GitHub Actions minutes, no Render build pipeline minutes, no CF build minutes. Requires Authorization: Bearer <api_key> on an ALREADY-PAID Starter/Pro/Growth (or suite) account. Unlike most metered AXIS tools, a free-tier account cannot unlock this per call with an MPP payment credential — there is no pay-per-call path here, only 'upgrade at iliad.trustfabric.ai/billing'. Once unlocked, billed $1.00 per call from the account's plan credits. Lite mode carries no discount here — the bundle is identical in both modes.

    mcp-tool

    {
  "type": "object",
  "required": [
    "snapshot_id"
  ],
  "properties": {
    "snapshot_id": {
      "type": "string",
      "description": "Existing AXIS snapshot_id to package into deploy artifacts"
    }
  }
}
    arguments 12 lines
  • search_and_discover_tools unknown never probed

    Search AXIS programs by keyword and return ranked matches with artifact paths. Free, no auth, and no stateful side effects. Example: q=checkout returns commerce-relevant programs first. Use this when you know the outcome you want but not the right program. Use list_programs instead for the full catalog, get_install_manifest for install metadata, or discover_agentic_purchasing_needs for purchasing-specific triage.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "q": {
      "type": "string",
      "description": "Search query — keyword or phrase"
    },
    "program": {
      "type": "string",
      "description": "Optional: filter results to a specific program name"
    }
  }
}
    arguments 13 lines
  • get_referral_credits unknown never probed

    Get the caller's referral earnings, milestones, and free-call status. Requires Authorization: Bearer <api_key>, has no usage charge, and returns the current discount ledger without creating a new analysis. Example: call after a referral campaign to inspect earned credits. Use this when you need balances and milestones. Use get_referral_code instead when you only need the shareable token.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • iliad_web_research unknown never probed

    Scrape a single URL with AXIS's owned crawler (SSRF-guarded fetch, robots.txt-aware, readability extraction — no third-party key) and return markdown-formatted content. Honest scope: fetches static HTML only, no JavaScript rendering, so client-rendered SPA pages may extract thin content. Returns markdown body, extracted metadata, and title. Best for research, documentation reading, or SEO analysis. Requires Authorization: Bearer <api_key>. Pricing: $0.10 per page. Lite mode carries no discount here — the markdown output is identical in both modes. If the operator's backend configuration is incomplete, this call returns {_not_configured:true} instead of scraping, and is not billed. Use iliad_web_research_crawl for crawling multiple pages or link following. To make a scraped page searchable later, index it with iliad_web_search.

    mcp-tool

    {
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "The URL to scrape (http or https)"
    },
    "only_main_content": {
      "type": "boolean",
      "default": true,
      "description": "Extract only the main content (default: true)"
    }
  }
}
    arguments 17 lines
  • iliad_web_research_crawl unknown never probed

    Crawl a domain with AXIS's owned crawler — a same-origin BFS frontier with robots.txt compliance and per-host politeness, no third-party key — and scrape multiple pages. Honest scope: static HTML only, no JavaScript rendering. Returns array of scraped pages with markdown content. Best for site mapping, content audits, or bulk research. Requires Authorization: Bearer <api_key>. Pricing: $0.01/page beyond your account's shared 100-page/month free pool (standard and lite) — a crawl fully covered by the free pool costs $0.00; a fully-paid 100-page crawl costs up to $1.00. If the operator's backend configuration is incomplete, this call returns {_not_configured:true} instead of crawling, and is not billed. Use iliad_web_research for single-page scrapes. To make crawled pages searchable later, index them with iliad_web_search.

    mcp-tool

    {
  "type": "object",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "The domain/URL to crawl (http or https)"
    },
    "limit": {
      "type": "number",
      "default": 10,
      "maximum": 100,
      "minimum": 1,
      "description": "Maximum pages to crawl (1-100, default: 10)"
    }
  }
}
    arguments 19 lines
  • iliad_object_storage unknown never probed

    AXIS-owned signed-URL minter backed by Cloudflare R2. Returns a pre-signed PUT or GET URL scoped to the calling account (keys are prefixed with `accounts/<account_id>/` server-side, so accounts can't reach each other's objects). Requires Authorization: Bearer <api_key>. Returns the URL plus expires_at (ISO 8601), bucket, and scoped_key. Returns `{_not_configured: true, ...}` when the operator has not provisioned R2_* env vars (no crash, no leaked secrets); not billed when not configured. Pricing: $0.01 standard, free in lite mode. TTL is capped at 86400 seconds (24h). Engineer mode (X-Agent-Mode: engineer — Managed Bucket, $0.05): adds delete + list + copy (server-side, no bytes through the agent) operations, content-addressed dedup keys (content_sha256), and mint-time PUT policy (pin content_type / exact content_length as signed headers R2 enforces). A signed GET URL minted here can be passed directly as iliad_document_parsing's document_url or iliad_speech_to_text's audio_url.

    mcp-tool

    {
  "type": "object",
  "required": [
    "key",
    "operation"
  ],
  "properties": {
    "ext": {
      "type": "string",
      "description": "Engineer mode: optional extension appended to the content-addressed key (e.g. 'png')."
    },
    "key": {
      "type": "string",
      "description": "Object key (max 1024 chars), or the prefix for operation=list. Path traversal and leading-/ are rejected."
    },
    "operation": {
      "enum": [
        "put",
        "get",
        "delete",
        "list",
        "copy"
      ],
      "type": "string",
      "description": "put / get (standard). delete / list / copy and content-addressed put require X-Agent-Mode: engineer (Managed Bucket)."
    },
    "source_key": {
      "type": "string",
      "description": "Engineer mode (operation=copy): source object key to copy from, scoped to your account; `key` is the destination. Echo the returned required_headers on the PUT."
    },
    "ttl_seconds": {
      "type": "number",
      "description": "Signed-URL lifetime, 1..86400. Defaults to 3600."
    },
    "content_type": {
      "type": "string",
      "description": "Engineer mode (put): pin the Content-Type the upload must send (signed; R2 rejects a mismatch). Printable ASCII type/subtype, ≤255 chars. Echo via required_headers."
    },
    "content_length": {
      "type": "number",
      "description": "Engineer mode (put): pin the EXACT byte size the upload must be (signed; ≤5 GiB). Pairs with content_sha256 for verified content-addressed writes."
    },
    "content_sha256": {
      "type": "string",
      "description": "Engineer mode: 64-char hex sha256 of the bytes you'll PUT. When set, the object lands under accounts/<id>/cas/<sha256> so identical content dedupes."
    }
  }
}
    arguments 48 lines
  • iliad_vector_database unknown never probed

    AXIS-owned vector store. Two operations: `upsert` (insert or replace vectors) and `query` (cosine top-k nearest neighbors). Namespaces are account-scoped server-side (`acct:<account_id>:<namespace>`), so tenants cannot read each other's vectors. Persistent across restarts via Postgres. Requires Authorization: Bearer <api_key>. Pricing: $0.01 standard, free in lite mode. Best for RAG retrievers, deduplication, and similarity search. Use iliad_embeddings to turn text into the vectors this tool stores and queries. Engineer mode (X-Agent-Mode: engineer — Managed Memory, $0.05): query runs a pgvector/HNSW ANN candidate pool with optional recency-decay reranking (recency_half_life_days — managed forgetting), RRF hybrid fusion (sparse_ids), and metadata filter; upsert applies intra-batch semantic-dedup (dedup_threshold).

    mcp-tool

    {
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "query": {
      "type": "object",
      "description": "{vector: number[], top_k?: number, filter?: object}. Engineer mode also reads recency_half_life_days (number — exponential recency decay) and sparse_ids (string[] — RRF hybrid fusion). Required for query."
    },
    "vectors": {
      "type": "array",
      "description": "Array of {id, vector, metadata?} — required for upsert."
    },
    "namespace": {
      "type": "string",
      "description": "Logical isolation key. Defaults to 'default'. Account ID is always prepended server-side."
    },
    "operation": {
      "enum": [
        "upsert",
        "query"
      ],
      "type": "string",
      "description": "upsert (insert/replace) or query (top-k cosine)."
    },
    "semantic_dedup": {
      "type": "boolean",
      "description": "Engineer upsert: set false to disable dedup (default on)."
    },
    "dedup_threshold": {
      "type": "number",
      "description": "Engineer upsert: cosine threshold for intra-batch semantic-dedup (default 0.97)."
    }
  }
}
    arguments 36 lines
  • iliad_embeddings unknown never probed

    Convert text into dense vectors. Accepts a single string or a batch (max 2048). Returns one vector per input. AXIS-owned in-process inference by default (node-llama-cpp + an embedding-capable GGUF at AXIS_EMBEDDING_MODEL_PATH — no upstream provider call); an optional OpenAI /v1/embeddings backend is available behind AXIS_EMBEDDING_BACKEND=openai (model: text-embedding-3-small by default, overridable via OPENAI_EMBEDDING_MODEL; reports token usage). Requires Authorization: Bearer <api_key> to call. Pricing: $0.05 standard, $0.02 lite. When the selected backend is not provisioned (local: GGUF file absent; openai: OPENAI_API_KEY unset), returns a structured `_not_configured: true` envelope naming the backend and remediation, and is not billed. Pairs natively with iliad_vector_database — feed `vectors` from this tool's output into `vector` of the vector_database upsert/query calls. Engineer mode (X-Agent-Mode: engineer — Domain Embeddings, $0.08): pass `dimensions` (Matryoshka truncation → smaller vectors) and/or `corpus_adapter: true` (mean-center the batch to sharpen retrieval on your data); returns an `engineer` block with the fitted adapter_mean for query alignment.

    mcp-tool

    {
  "type": "object",
  "required": [
    "input"
  ],
  "properties": {
    "input": {
      "type": [
        "string",
        "array"
      ],
      "description": "A single string or an array of strings to embed. Empty strings and entries > 32k chars are rejected (chunk before calling)."
    },
    "dimensions": {
      "type": "number",
      "description": "Engineer mode: truncate each vector to this many leading dims (Matryoshka) + renormalize. Smaller, cheaper vectors."
    },
    "corpus_adapter": {
      "type": "boolean",
      "description": "Engineer mode: mean-center the batch (all-but-the-mean) to sharpen retrieval; returns the fitted adapter_mean."
    }
  }
}
    arguments 23 lines
  • iliad_transactional_email unknown never probed

    Send a single transactional email. Requires Authorization: Bearer <api_key>. Provide either body_html, body_text, or both (Resend will pick the best variant per recipient). All emails ship from RESEND_FROM_ADDRESS — operator must verify that domain in Resend before sending. Returns the provider-assigned message_id plus the accepted recipient list. Pricing: $0.02 standard, $0.01 lite. Returns a structured _not_configured envelope when RESEND_API_KEY or RESEND_FROM_ADDRESS is missing, and is not billed. Recipients capped at 50 per call; subject capped at 998 chars; bodies capped at 1 MB. Engineer mode (X-Agent-Mode: engineer — Deliverability, $0.50): instead of sending, pass a `domain` and get a full SPF/DKIM/DMARC setup (fresh DKIM keypair) + sender warmup schedule + verification checklist — no email sent, no ESP key needed.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "to": {
      "type": [
        "string",
        "array"
      ],
      "description": "Recipient address or array of addresses (max 50). Required for a send (standard mode)."
    },
    "domain": {
      "type": "string",
      "description": "Engineer mode (Deliverability): domain to generate SPF/DKIM/DMARC setup for. Replaces the send."
    },
    "subject": {
      "type": "string",
      "description": "Email subject (max 998 chars, RFC 5322)."
    },
    "provider": {
      "type": "string",
      "description": "Engineer mode: ESP for the SPF include (resend/sendgrid/mailgun/postmark/ses/google). Defaults resend."
    },
    "reply_to": {
      "type": "string",
      "description": "Optional Reply-To address."
    },
    "body_html": {
      "type": "string",
      "description": "HTML body. At least one of body_html / body_text required."
    },
    "body_text": {
      "type": "string",
      "description": "Plaintext body. At least one of body_html / body_text required."
    },
    "dmarc_policy": {
      "type": "string",
      "description": "Engineer mode: DMARC policy none|quarantine|reject. Defaults none (monitoring)."
    },
    "dkim_selector": {
      "type": "string",
      "description": "Engineer mode: DKIM selector (alphanumeric/hyphen, 1-32). Defaults 'axis'."
    }
  }
}
    arguments 44 lines
  • iliad_llm_inference unknown never probed

    AXIS-hosted LLM chat-completion via node-llama-cpp + a small GGUF model loaded in-process. Two input shapes accepted: `prompt` (single string) or `messages` (chat-style array of {role, content}). Sampling controls: `max_tokens` (≤2048), `temperature` (0-2), `top_k`, `top_p`, `seed` (threaded through for more deterministic output — NOT a proven byte-identical guarantee; thread count isn't pinned and GGML's multi-threaded matmul reduction order isn't guaranteed bit-exact across runs), `stop` (string[]). Inference runs in-process — no upstream LLM provider call — but this AXIS tool call is still billed: $0.02 standard, $0.01 lite. Operator sets AXIS_LLM_MODEL_PATH to point at a Phi-3-mini / TinyLlama / Llama-3.2-1B GGUF; if missing, the tool returns a `_not_configured: true` envelope and is not billed. Engineer mode (X-Agent-Mode: engineer — Constrained Inference, $0.10): pass a `json_schema` and decoding is grammar-constrained to it AND the output is validated against it (returns a `structured` block with valid + parsed + schema_errors) — guaranteed-valid structured output. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "seed": {
      "type": "number",
      "description": "Optional seed, threaded through with temperature for more deterministic output. Not a proven byte-identical guarantee (thread count/matmul reduction order isn't pinned) — see the tool description."
    },
    "stop": {
      "type": "array",
      "description": "Stop sequences. Generation halts when any string in the array is produced."
    },
    "top_k": {
      "type": "number",
      "description": "Top-k sampling (positive integer). Defaults 40."
    },
    "top_p": {
      "type": "number",
      "description": "Top-p nucleus sampling in (0, 1]. Defaults 0.95."
    },
    "prompt": {
      "type": "string",
      "description": "Single-prompt completion input. Use either this OR messages, not both."
    },
    "system": {
      "type": "string",
      "description": "Optional system prompt (prompt mode only). For messages mode, use role=system entries."
    },
    "messages": {
      "type": "array",
      "description": "Chat-style input. Array of {role: system|user|assistant, content: string}."
    },
    "max_tokens": {
      "type": "number",
      "description": "Max tokens to generate. Defaults 512, hard cap 2048."
    },
    "json_schema": {
      "type": "object",
      "description": "Engineer mode (required): a JSON Schema. Decoding is grammar-constrained to it and the output is validated against it; returns a `structured` block."
    },
    "temperature": {
      "type": "number",
      "description": "Sampling temperature in [0, 2]. Defaults 0.7."
    }
  }
}
    arguments 45 lines
  • iliad_code_sandbox unknown never probed

    AXIS-owned secure code execution. Each call spawns a fresh ephemeral Docker container with hardened isolation: no network, read-only root filesystem, all Linux capabilities dropped, no-new-privileges, PID/memory/CPU limits, tmpfs /tmp only, runs as nobody:nobody. Container is force-removed after each call. Supports python | node | bash via the multi-runtime image `nikolaik/python-nodejs:python3.12-nodejs22-slim` (operator can override via AXIS_CODE_SANDBOX_IMAGE). Returns stdout/stderr/exit_code/timed_out/duration_ms/image. Wall-clock timeout enforced via SIGKILL + force-remove. Source is fed via stdin (no fs write to the read-only root). Code body capped at 256 KiB; stdin at 1 MiB; timeout 1-600 seconds (default 30); stdout/stderr each capped at 1 MiB output. Pricing: $0.05 standard, $0.02 lite — billed whenever a container actually ran, including a timeout or non-zero exit code. Not billed when the call instead returns `_not_configured: true`: no Docker daemon reachable (Render standard services don't expose /var/run/docker.sock), the operator has set AXIS_CODE_SANDBOX_DISABLED=1, or more than AXIS_SANDBOX_MAX_CONCURRENT (default 4) runs are already in flight (reason sandbox_busy — transient, retry shortly). Engineer mode (X-Agent-Mode: engineer — Verified Exec, $0.25): the result includes an Ed25519-signed attestation binding code-hash → output-hash + a per-account hash-chain entry, so another agent that pins AXIS's published key can verify the run without re-executing it. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "required": [
    "language",
    "code"
  ],
  "properties": {
    "code": {
      "type": "string",
      "description": "Source code to execute. Fed via stdin to the interpreter. Max 256 KiB."
    },
    "stdin": {
      "type": "string",
      "description": "Optional additional stdin appended after the code body. Max 1 MiB."
    },
    "language": {
      "enum": [
        "python",
        "node",
        "bash"
      ],
      "type": "string",
      "description": "Runtime language."
    },
    "timeout_seconds": {
      "type": "number",
      "description": "Wall-clock limit. Defaults 30, max 600. SIGKILL on overrun."
    }
  }
}
    arguments 30 lines
  • iliad_document_parsing unknown never probed

    AXIS-owned document → Markdown extractor. Accepts either `document_url` (https fetch + 50 MiB cap + 60s timeout) or `document_base64` (inline bytes, 50 MiB decoded cap) — exactly one. Optional `mime_type` hint (application/pdf, application/vnd.openxmlformats-officedocument.wordprocessingml.document, text/html, text/markdown, text/plain); we sniff from magic bytes + URL extension when omitted. Format dispatch: PDF → pdfjs-dist text extraction (one block per page with `--- page N ---` separators); DOCX → mammoth → markdown (tables preserved); HTML → tag-strip with heading + list + entity handling (NOT a full HTML→MD converter — bring turndown if you need fancier); plain text + markdown → passthrough. Returns `{markdown, format_detected, byte_size, page_count, table_count, truncated}`. Output capped at 1 MiB markdown with a truncation marker. Pricing: $0.02 standard, $0.01 lite. Engineer mode (X-Agent-Mode: engineer — Document Intelligence, $0.10): adds an `engineer` block with retrieval chunks (heading-aware, overlapping) + extract-to-caller-schema (pass `json_schema` → a grammar-constrained, validated typed object) + image OCR (image/* via document_base64, capped at 10 MiB — smaller than the 50 MiB document cap; an OCR failure or oversized image returns a descriptive `reason` that may not match the standard-mode enum) — typed data, not just markdown. document_url accepts a signed GET URL minted by iliad_object_storage; chain the extracted markdown into iliad_embeddings + iliad_vector_database to build a RAG index. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "mime_type": {
      "type": "string",
      "description": "Optional MIME-type hint. When omitted we sniff from magic bytes + URL extension. Engineer mode: an image/* mime triggers OCR."
    },
    "json_schema": {
      "type": "object",
      "description": "Engineer mode: a JSON Schema. The document is extracted into a validated object matching it (returned in engineer.extracted)."
    },
    "document_url": {
      "type": "string",
      "description": "https URL to a document. Use this OR document_base64, not both."
    },
    "document_base64": {
      "type": "string",
      "description": "Base64-encoded document bytes. Use this OR document_url, not both."
    }
  }
}
    arguments 21 lines
  • iliad_web_search unknown never probed

    AXIS-owned BM25 search engine over the corpus YOUR account has indexed. NOT a Google/Bing scraper — agents build their own searchable index by first calling operation='index' with documents (often pages fetched via iliad_web_research), then querying with operation='search'. Five operations: `index` (insert one or many documents), `search` (BM25 top-k ranked hits with snippet + score + metadata), `delete` (drop one doc), `delete_namespace` (drop all), `count`. Namespaces are account-scoped server-side (`acct:<id>:<namespace>`). Persistent across restarts via Postgres (the shared @axis/snapshots database). Search supports `max_results` (default 10, max 100) and `site` (restrict to a single URL host, case-insensitive). Only operation='search' is billed ($0.01 standard, free in lite mode) — index, delete, delete_namespace, and count are always free. Engineer mode (X-Agent-Mode: engineer — Answer Engine, $0.25): search also returns a grounded extractive answer with [n] citation spans over your corpus, reranked, refusing on weak evidence. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "site": {
      "type": "string",
      "description": "Filter to a single URL host (e.g. 'docs.python.org', case-insensitive)."
    },
    "query": {
      "type": "string",
      "description": "Search query (1-1024 chars). Required in search mode."
    },
    "doc_id": {
      "type": "string",
      "description": "Document id to remove. Required in delete mode."
    },
    "document": {
      "type": "object",
      "description": "Single document {doc_id, url?, title?, content, metadata?} — used in index mode (alternative to documents[])."
    },
    "documents": {
      "type": "array",
      "description": "Batch of documents (max 100). Transactional — malformed entry aborts the whole call."
    },
    "namespace": {
      "type": "string",
      "description": "Logical isolation key. Defaults 'default'. Account id is always prepended server-side."
    },
    "operation": {
      "enum": [
        "index",
        "search",
        "delete",
        "delete_namespace",
        "count"
      ],
      "type": "string",
      "description": "index | search | delete | delete_namespace | count."
    },
    "max_results": {
      "type": "number",
      "description": "Cap on hits returned. Defaults 10, max 100."
    }
  }
}
    arguments 47 lines
  • iliad_text_to_speech unknown never probed

    AXIS-owned voice synthesis via Piper (rhasspy/piper) + ffmpeg-static. Accepts `text` (1-5000 chars), optional `voice` slug (filename without extension; defaults to AXIS_PIPER_DEFAULT_VOICE or the first available voice), optional `format` (wav | mp3 | opus; defaults wav), optional `sentence_silence` (0-5 seconds, default 0.2). Returns `{audio_base64, format, voice_used, sample_rate, duration_seconds, byte_size}`. Inference runs in-process — no upstream provider call — but this AXIS tool call is still billed: $0.02 standard, $0.01 lite. When operator hasn't installed piper or placed voice .onnx + .onnx.json files in AXIS_PIPER_VOICE_DIR (default models/piper/), returns `{_not_configured: true, reason, detail, remediation}` and is not billed. format=mp3/opus additionally requires ffmpeg-static. Engineer mode (X-Agent-Mode: engineer — Brand Voice, $0.10): requires `brand_text` (a brand / voice-and-tone artifact — the call throws without it in engineer mode) and AXIS auto-derives the voice persona (Piper voice slug + sentence pacing) and synthesizes in it; the persona is echoed in the response. Use iliad_speech_to_text to transcribe audio back to text. Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to speak. 1-5000 chars after trim."
    },
    "voice": {
      "type": "string",
      "description": "Voice slug (filename without extension, e.g. 'en_US-amy-medium'). Defaults to first available voice or AXIS_PIPER_DEFAULT_VOICE."
    },
    "format": {
      "enum": [
        "wav",
        "mp3",
        "opus"
      ],
      "type": "string",
      "description": "Audio codec."
    },
    "gender": {
      "enum": [
        "female",
        "male"
      ],
      "type": "string",
      "description": "Engineer mode: persona gender override."
    },
    "locale": {
      "enum": [
        "us",
        "gb"
      ],
      "type": "string",
      "description": "Engineer mode: persona locale override."
    },
    "brand_text": {
      "type": "string",
      "description": "Required when X-Agent-Mode: engineer is set (the call throws without it); ignored otherwise. Brand / voice-and-tone artifact — AXIS derives a voice persona from it and synthesizes in that voice (overrides voice/sentence_silence)."
    },
    "sentence_silence": {
      "type": "number",
      "description": "Per-sentence silence in seconds (0-5). Defaults 0.2."
    }
  }
}
    arguments 49 lines
  • iliad_analytics unknown never probed

    AXIS-owned product analytics. Two operations: `capture` (insert events) and `query` (aggregations). Capture accepts a single `event` or a batch via `events[]` (max 500). Query kinds: `count` (total events), `count_by_event` (top events by frequency), `distinct_users` (unique user_id count), `count_by_bucket` (time-series with minute/hour/day buckets). All queries support optional `event`, `from_ts`, `to_ts`, and `property_filter` filters. Namespaces are account-scoped server-side (`acct:<account_id>:<namespace>`). Persistent across restarts via Postgres (the shared @axis/snapshots database). Pricing: $0.01 standard, free in lite mode. Requires Authorization: Bearer <api_key>. Best for funnels, cohorts, and retention on workloads up to ~1M events per account.

    mcp-tool

    {
  "type": "object",
  "required": [
    "operation"
  ],
  "properties": {
    "event": {
      "type": "object",
      "description": "Single event payload {event, user_id?, properties?, timestamp?} — used in capture mode."
    },
    "query": {
      "type": "object",
      "description": "{kind, event?, from_ts?, to_ts?, property_filter?, bucket?, limit?} — used in query mode."
    },
    "events": {
      "type": "array",
      "description": "Batch of event payloads (max 500). Transactional — partial inserts never persist."
    },
    "namespace": {
      "type": "string",
      "description": "Logical isolation key. Defaults to 'default'. Account id is always prepended server-side."
    },
    "operation": {
      "enum": [
        "capture",
        "query"
      ],
      "type": "string",
      "description": "capture or query."
    }
  }
}
    arguments 32 lines
  • axis_validate unknown never probed

    Validate an avatar mesh against 38 rules; returns pass/warn/fail counts. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.

    mcp-tool

    {
  "type": "object",
  "required": [
    "file_path"
  ],
  "properties": {
    "profile": {
      "enum": [
        "default",
        "strict",
        "lenient"
      ],
      "type": "string",
      "description": "Validation strictness profile"
    },
    "platform": {
      "enum": [
        "unity",
        "unreal",
        "godot",
        "roblox",
        "axis_engine"
      ],
      "type": "string",
      "description": "Target platform for platform-specific validation"
    },
    "file_path": {
      "type": "string",
      "description": "Path to mesh file (.glb, .obj, .stl, etc.)"
    }
  }
}
    arguments 32 lines
  • axis_inspect unknown never probed

    Inspect an avatar's contract state and provenance chain. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.

    mcp-tool

    {
  "type": "object",
  "required": [
    "file_path"
  ],
  "properties": {
    "file_path": {
      "type": "string",
      "description": "Path to mesh file (.glb, .obj, .stl, etc.)"
    }
  }
}
    arguments 12 lines
  • axis_compare unknown never probed

    Compare two avatar contracts; returns similarity score and section-level diffs. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.

    mcp-tool

    {
  "type": "object",
  "required": [
    "file_a",
    "file_b"
  ],
  "properties": {
    "file_a": {
      "type": "string",
      "description": "Path to first mesh file"
    },
    "file_b": {
      "type": "string",
      "description": "Path to second mesh file"
    },
    "sections": {
      "type": "array",
      "description": "Limit comparison to specific contract sections"
    }
  }
}
    arguments 21 lines
  • axis_manifest_verify unknown never probed

    Verify an export manifest's integrity and optionally check content hash. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.

    mcp-tool

    {
  "type": "object",
  "required": [
    "manifest"
  ],
  "properties": {
    "manifest": {
      "type": "object",
      "description": "Export manifest JSON object"
    },
    "expected_hash": {
      "type": "string",
      "description": "Expected content hash for verification"
    }
  }
}
    arguments 16 lines
  • roblox_compliance_check unknown never probed

    Run Roblox R15 compliance checks against a mesh. Status: **planned_proxy** — an estate-flagged proxy is planned (see discover_estate_tools for the sibling's own direct endpoint and price today). Calls return a planned-capability envelope pointing at AXIS Foundry (https://api.avatar.jonathanarvay.com/mcp) as the recommended interim provider. When the estate proxy ships, the dispatch handler swaps in without changing this schema.

    mcp-tool

    {
  "type": "object",
  "required": [
    "file_path"
  ],
  "properties": {
    "file_path": {
      "type": "string",
      "description": "Path to mesh file (.glb, .obj, .stl, etc.)"
    }
  }
}
    arguments 12 lines
  • iliad_hygiene unknown never probed

    AXIS-owned workspace hygiene grader. Analyzes an inline file set [{path,content}] and returns a letter grade (A-F) across a closed set of dimensions plus structured findings. Two modes: mode='scan' (DEFAULT, FREE) returns grade + findings (committed-secret scan, .env/secret-file detection, .gitignore gaps for build/scratch artifacts, oversized blobs, stub/placeholder markers, byte-identical duplicate files, source test-peer coverage, TODO/FIXME debt); mode='fix' (METERED, $0.05 standard / $0.02 lite) adds a prioritized remediation plan with ready-to-apply .gitignore additions and per-finding actions. Sending X-Agent-Mode: engineer always bills the fix-mode price, even if mode is 'scan' or omitted. Deterministic, dependency-free, never mutates your repo (fix returns a PLAN). Rules needing a live git checkout/toolchain (worktree pruning, build/vet, governance-source-of-truth checks, route-registration dup-handler analysis, ROI-queue coherence) are reported as repo_only_rules, not run. Engineer mode (X-Agent-Mode: engineer — Security Engineer, $5): the fix arrives as a git-applyable unified-diff patch (`patch`) + a SARIF 2.1.0 log for CI code-scanning (`sarif`). Requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "required": [
    "files"
  ],
  "properties": {
    "mode": {
      "enum": [
        "scan",
        "fix"
      ],
      "type": "string",
      "description": "scan (free grade+findings, default) | fix (metered, adds remediation plan)."
    },
    "files": {
      "type": "array",
      "description": "Inline files [{path, content}] to scan (non-empty; each content <= 5 MB)."
    },
    "config": {
      "type": "object",
      "description": "Optional threshold overrides: maxFileBytes, coverageA, coverageB, coverageC, todoDebtThreshold."
    }
  }
}
    arguments 24 lines
  • sca_exemption_decision unknown never probed

    Decide the lighter-SCA path for a single transaction using AXIS's published 7-priority PSD2 exemption matrix (the same decideScaExemption engine that renders the SCA Exemption Decision Matrix in generated artifacts). Input: amount_eur (required, PSD2 thresholds are EUR-denominated — convert before calling) plus optional context flags (secure corporate program, MIT, fixed recurring + prior SCA, trusted beneficiary + prior SCA, one-leg-out, acquirer TRA fraud rate in basis points). Returns the chosen exemption, its priority, sca_required, rationale, fallback path, all applicable candidates, the rendered priority matrix, and a sha256 reproducibility proof. Free, no auth, deterministic, no side effects. HONESTY: decision-support only, NOT an authorization oracle — final exemption eligibility is decided by the acquirer/issuer; TRA caps use published EBA RTS Art. 15 bands, not your acquirer's live fraud rate.

    mcp-tool

    {
  "type": "object",
  "required": [
    "amount_eur"
  ],
  "properties": {
    "amount_eur": {
      "type": "number",
      "description": "Transaction amount in EUR (PSD2 thresholds are EUR-denominated)."
    },
    "has_prior_sca": {
      "type": "boolean",
      "description": "A prior SCA exists — gates recurring_fixed and trusted_beneficiary."
    },
    "is_one_leg_out": {
      "type": "boolean",
      "description": "Payer or payee outside the EEA (territorial scope, not a formal exemption)."
    },
    "is_recurring_fixed": {
      "type": "boolean",
      "description": "Fixed-amount subsequent collection (RTS Art. 13). Requires has_prior_sca."
    },
    "is_secure_corporate": {
      "type": "boolean",
      "description": "Dedicated/lodged corporate card program (RTS Art. 16)."
    },
    "is_merchant_initiated": {
      "type": "boolean",
      "description": "MIT with stored credential + original SCA reference (out of SCA scope)."
    },
    "is_trusted_beneficiary": {
      "type": "boolean",
      "description": "Merchant on the cardholder's trusted list (RTS Art. 12). Requires has_prior_sca."
    },
    "tra_acquirer_fraud_bps": {
      "type": "number",
      "description": "Acquirer reference fraud rate in basis points (EBA RTS Art. 15 bands: <=1 → €500 cap, <=6 → €250, <=13 → €100)."
    }
  }
}
    arguments 40 lines
  • grade_compliance unknown never probed

    Run the real 8-check AP2/Visa compliance grading engine (gradeCompliance — the same engine behind computeComplianceGrade and the commerce registry's verified_decisions block) over an inline file set. Each of the 8 validators (SCA/3DS2 readiness, AP2 mandate validity, tokenization posture, CE 3.0 readiness, dispute rail wiring, idempotency/receipt hygiene, budget negotiation, refund/cancel path) is a multi-signal check with weight, evidence trail, and remediation. Returns grade A-D, score, checks_passed/8, the full checks[] detail, detected commerce signals, and a sha256 reproducibility proof. Free, no auth, deterministic, no snapshot persisted. Hard caps: 25 files / 50KB per file / 1MB total. HONESTY: deterministic static source-signal analysis — a checklist starting point, NOT a certification, audit, PCI assessment, or card-network certification.

    mcp-tool

    {
  "type": "object",
  "required": [
    "files"
  ],
  "properties": {
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "path",
          "content"
        ],
        "properties": {
          "path": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        }
      },
      "description": "Source files to grade (max 25 files, 50KB each, 1MB total)"
    }
  }
}
    arguments 27 lines
  • assemble_ce3_evidence unknown never probed

    Assemble a Visa Compelling Evidence 3.0 packet + eligibility verdict for a disputed card-absent-fraud (reason code 10.4) transaction using the real assembleCe3 engine: finds prior undisputed transactions in the caller-supplied history that share >=2 qualified data elements (device_id / ip_address / email / shipping_address / login_id) and fall 120-365 days before the disputed transaction, per CE 3.0 rules. Returns {eligible, qualifying_priors, matched_element_union, rejection_reason?, evidence_packet, caveat} plus a sha256 reproducibility proof. Free, no auth, deterministic, no side effects. HONESTY: CE 3.0 applies to reason code 10.4 ONLY (10.2/10.3 are card-present conditions), and this is ASSEMBLY ONLY — not a submission to VROL/Verifi (use assemble_representment for the Stripe representment path). AXIS does not publish win-rate estimates.

    mcp-tool

    {
  "type": "object",
  "required": [
    "dispute"
  ],
  "properties": {
    "dispute": {
      "type": "object",
      "description": "{txn: {id, amount_minor, currency, created_at, disputed, device_id?, ip_address?, email?, shipping_address?, login_id?}, reason_code: string (CE 3.0 requires '10.4'), disputed_at: ISO timestamp}"
    },
    "transaction_history": {
      "type": "array",
      "description": "Candidate prior transactions (same Txn shape, max 500). Undisputed priors sharing >=2 qualified elements qualify."
    }
  }
}
    arguments 16 lines
  • build_ap2_mandate unknown never probed

    Validate, canonically encode, and optionally Ed25519-sign an AP2 mandate (Intent / Cart / Payment) using the real @axis/ap2 codecs — schema validation (including cart-total arithmetic and intent cross-references), RFC 8785 JCS-style canonical JSON encoding, and detached-JWS EdDSA signing over node:crypto. Pass seed_hex (64 hex chars = 32 bytes) to sign deterministically client-side-supplied key material — AXIS stores no keys; omit it for an unsigned template with encoding only. The signed envelope round-trips through verifyMandate before it is returned. Free, no auth, deterministic (Ed25519 signatures are deterministic per RFC 8032), no side effects. SCOPE HONESTY: conformant to AXIS's TypeScript encoding of the public AP2 mandate schema, verified against self-authored golden vectors — NOT certified against an official AP2 conformance suite or a live network counterparty.

    mcp-tool

    {
  "type": "object",
  "required": [
    "mandate"
  ],
  "properties": {
    "mandate": {
      "type": "object",
      "description": "An AP2 mandate object: {kind: 'intent'|'cart'|'payment', version: 'ap2/1', id, created_at, ...kind-specific fields (intent: user_id/description/constraints.max_amount/expires_at; cart: intent_ref/merchant_id/items[]/total; payment: cart_ref/method/amount)}."
    },
    "seed_hex": {
      "type": "string",
      "description": "Optional 64-char hex (32-byte) Ed25519 seed to sign with. Caller-supplied key material — AXIS stores no keys. Omit for an unsigned template."
    },
    "intent_context": {
      "type": "object",
      "description": "Optional IntentMandate to cross-reference a cart's intent_ref against."
    }
  }
}
    arguments 20 lines
  • score_dispute_readiness unknown never probed

    Score how ready a disputed transaction's EVIDENCE FILE is for representment, per Visa reason-code family, using the transparent scoreWinProbability heuristic (win-prob-v0: hand-set, documented logistic coefficients — exported, inspectable, monotonic in evidence). Input: reason_code + the evidence on file (CE 3.0 eligibility, matching data elements, prior undisputed transactions, delivery proof, AVS/CVV, 3DS, signed mandate, customer communication). Returns the heuristic score, band, top missing evidence (what to capture next), recommended action, rationale, model version, and a sha256 reproducibility proof. Free, no auth, deterministic. HONESTY (read this): this scores evidence-capture readiness and is NOT a dispute-win prediction — the v0 heuristic is NOT empirically calibrated against real network outcomes, is NOT a Visa-published or Visa-endorsed win rate, and AXIS does not publish win-rate estimates. Treat it as a prioritization signal for evidence gathering only; always follow your operator's dispute policy.

    mcp-tool

    {
  "type": "object",
  "required": [
    "reason_code"
  ],
  "properties": {
    "evidence": {
      "type": "object",
      "description": "Evidence on file: {ce3Eligible?, matchingDataElements? (0-5), priorUndisputedTransactions? (0-10), hasDeliveryProof?, hasAvsMatch?, hasCvvMatch?, has3dsAuthenticated?, hasSignedMandate?, hasCustomerCommunication?}. Omitted fields default to false/0."
    },
    "reason_code": {
      "type": "string",
      "description": "Visa dispute reason code (e.g. '10.4', '13.1', '12.5'). Unknown codes fall back to a documented default family."
    }
  }
}
    arguments 16 lines
  • assemble_representment unknown never probed

    Turn a webhook-ingested dispute (charge.dispute.* events persist DisputeRecords server-side) into a Stripe representment: qualifies CE 3.0 priors from your supplied transaction history (assembleCe3), builds the Stripe `evidence` hash (buildStripeRepresentment), walks the dispute state machine (needs_response → evidence_assembling → evidence_submitted) with a full transition ledger, and — when submit=true and Stripe is configured — submits the evidence through the live Stripe disputes API. Requires Authorization: Bearer <api_key>; metered ($1.00 standard, $0.50 lite) through the standard authorize/capture path — a failed assembly never charges. Returns {dispute, evidence, ce3, ce3_eligible, submitted, disclaimer}. HONESTY: the dispute lifecycle is LIVE on the Stripe rail only; VROL/RDR/CDRN (Verifi/Ethoca) is integration-ready code gated on acquirer provisioning (AXIS_ENABLE_VROL) and never fakes a submission. AXIS does not publish win-rate estimates.

    mcp-tool

    {
  "type": "object",
  "required": [
    "dispute_id"
  ],
  "properties": {
    "submit": {
      "type": "boolean",
      "description": "true → submit the built evidence to the Stripe disputes API (requires STRIPE_SECRET_KEY server-side). Default false (assemble only)."
    },
    "dispute_id": {
      "type": "string",
      "description": "Provider dispute id (Stripe dp_...) previously ingested by the charge.dispute.created webhook."
    },
    "disputed_txn": {
      "type": "object",
      "description": "Optional CE 3.0 data elements of the disputed transaction: {device_id?, ip_address?, email?, shipping_address?, login_id?}."
    },
    "evidence_inputs": {
      "type": "object",
      "description": "{customerEmail?, shippingAddress?, billingAddress?, serviceDate?, productDescription?, deliveryTracking?, threeDsAuthenticated?} — merchant-supplied evidence fields."
    },
    "transaction_history": {
      "type": "array",
      "description": "Candidate prior transactions for CE 3.0 qualification (Txn shape, max 500)."
    }
  }
}
    arguments 28 lines
  • iliad_network_tokenization unknown never probed

    Network-tokenization capability. (1) `lifecycle`: an EXECUTABLE TAP-style token-lifecycle state machine (provision → activate → suspend → resume → delete; deleted is terminal; illegal transitions are rejected with an error, not silently accepted) — pure simulation, no real payment method involved. (2) `capabilities` reports which providers are configured (env-derived). (3) `read` and (4) `provision` are TEMPORARILY DISABLED: both would resolve a caller-supplied payment_method_id/pan_source against the platform's Stripe account, and this service has no way yet to verify that id belongs to the calling AXIS account — calling either always returns a structured `_not_configured: true` envelope explaining this, never real payment-method data. (For context once re-enabled: `read`'s underlying Stripe adapter is fully implemented; direct VTS/MDES `provision` is additionally capability-gated behind a network-issued Token Requestor ID — AXIS_VTS_TOKEN_REQUESTOR_ID / AXIS_MDES_TOKEN_REQUESTOR_ID — plus network onboarding, and NEVER fakes a token.) Raw PANs are never accepted even when disabled (pan_source is documented as an opaque reference only). Free (unmetered); requires Authorization: Bearer <api_key>.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "event": {
      "type": "string",
      "description": "lifecycle: single-event shorthand for `events: [event]`."
    },
    "events": {
      "type": "array",
      "description": "lifecycle: ordered TokenEvent list (provision|activate|suspend|resume|delete), max 100. Must start from provision; illegal transitions throw."
    },
    "provider": {
      "enum": [
        "stripe",
        "vts",
        "mdes"
      ],
      "type": "string",
      "description": "provision: ignored — this operation is disabled and always returns _not_configured."
    },
    "operation": {
      "enum": [
        "read",
        "provision",
        "lifecycle",
        "capabilities"
      ],
      "type": "string",
      "description": "read (default, disabled) | provision (disabled) | lifecycle | capabilities."
    },
    "pan_source": {
      "type": "string",
      "description": "provision: ignored — this operation is disabled and always returns _not_configured. NEVER a raw PAN in any case."
    },
    "payment_method_id": {
      "type": "string",
      "description": "read: ignored — this operation is disabled and always returns _not_configured."
    }
  }
}
    arguments 40 lines
  • get_referral_code unknown never probed

    Get or create the caller's AXIS referral token. Requires Authorization: Bearer <api_key>, has no usage charge, and may persist a new referral code if one does not exist yet. Example: call before sharing AXIS with another agent or workspace. Use this when you need the shareable token itself. Use get_referral_credits instead when you need balances, milestones, and discount status.

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
_ try it over mcp through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ is this your agent? claim it: badge, payouts, history

Nobody has claimed this listing. Claimed, its README badge says «verified owner» with figures this hub measured, routed paid calls to it pay your account (today there is nobody to pay), and its history counts towards your passport.

  1. Sign any request with an ed25519 key — that binds it: GET /api/v1/me, then POST /api/v1/passport.
  2. Prove it is yours. Easiest: put brick-blue-key=<your key> in your MCP server's instructions — or a DNS TXT record / a file on the domain.
  3. Ask the hub to check: POST /api/v1/passport/claim-endpoint with this listing's id 08625ef2a488a68d.

Every step, filled in for this listing: https://brick.blue/api/v1/agents/08625ef2a488a68d/claim. Over MCP: the claim_endpoint tool.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/08625ef2a488a68d/badge.svg)](https://brick.blue/agent/08625ef2a488a68d?ref=badge)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Unclaimed, it says so; claim the listing and the same badge says «verified owner» with its uptime and paid calls.

_ how we knowoff the mcp door
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
2
ok
0
failed
2
success rate
0%
median latency
228ms
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

2 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.