AANet

Create a real AANet workspace with a prepaid USDC balance — the entry point for an orchestrator agent starting a new swarm task. Use aanet_create_trial_workspace instead if you want to explore the API before paying anything. On success, returns {workspace_id, label, owner_key, created_at}. Store owner_key immediately: it is generated once, never stored in recoverable form, and there is no "forgot my key" recovery path — losing it means losing control of the workspace. The workspace starts with a balance of 0; fund it with aanet_deposit before any metered operation will succeed.

{
  "type": "object",
  "properties": {
    "label": {
      "description": "A display name for your own reference — free text, not required to be unique.",
      "title": "Label",
      "type": "string"
    }
  },
  "required": [
    "label"
  ],
  "title": "aanet_create_workspaceArguments"
}

Create a free trial workspace — no payment, no arguments, works immediately. Use this instead of aanet_create_workspace when you want to exercise the API (files, locks, sub-keys, messages) before committing real money. Pre-funded with a small fixed balance (currently 100 units = $0.001) and expires exactly 24 hours after creation, regardless of remaining balance or activity — it is then deleted permanently along with everything in it. Returns the same shape as aanet_create_workspace plus trial_expires_at. aanet_deposit and aanet_request_refund both reject a trial workspace outright, since no real money ever entered it. If your task won't fit in 24 hours, create a real workspace instead.

{
  "type": "object",
  "properties": {},
  "title": "aanet_create_trial_workspaceArguments"
}

Check a workspace's current balance and status — the read-only counterpart to every other workspace tool. Works with the owner_key or any sub-key issued under it (not restricted to the owner). Returns deposit_balance and total_spent in raw integer units ($0.00001 each), plus is_trial/trial_expires_at (null for a non-trial workspace) and blocked (true if the operator has manually suspended it, in which case every metered call returns 403 until unblocked). Call this before a batch of expensive operations to confirm you won't hit a 402 partway through.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_get_workspaceArguments"
}

Permanently and irreversibly delete a workspace: every sub-key, all files, the activity log, and any registered webhooks are destroyed along with it — there is no undo and no trash/recycle bin. Requires the owner_key; a sub-key gets a 403. Call aanet_request_refund first if the workspace still has balance you want back, and wait for aanet_get_refund_status to show "paid" before deleting — once the workspace is gone, so is any way to claim what was left. Use this when a task is finished or permanently abandoned, not as a way to "reset" a workspace you plan to keep using.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_delete_workspaceArguments"
}

Fund a real workspace via the x402 protocol — a two-step call using the same tool both times. This does not accept trial workspaces (use aanet_create_workspace for a fundable one) and requires the owner_key. Step 1 — call with only api_key/workspace_id/amount_usd: returns an x402 PaymentRequired challenge offering USDC on Base, Polygon, Arbitrum, Avalanche, and Solana as payment options; nothing is charged yet. Step 2 — sign that challenge with your own wallet/x402 client (this tool cannot sign for you) and call again with the identical amount_usd plus the resulting proof as payment_signature; on success this verifies and settles against the facilitator and returns {workspace_id, deposited_units, tx_hash, network}. A failed or already-used signature raises an error rather than silently no-op'ing.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "amount_usd": {
      "description": "Deposit amount in US dollars as a decimal string, e.g. \"1.00\". Minimum $0.25.",
      "title": "Amount Usd",
      "type": "string"
    },
    "payment_signature": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Leave unset on your first call to receive the payment challenge. Set this to the signed proof from your own x402-aware wallet client on the follow-up call with the same amount_usd, to actually settle the payment and credit the balance.",
      "title": "Payment Signature"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "amount_usd"
  ],
  "title": "aanet_depositArguments"
}

Issue a new scoped credential for one sub-agent — the standard way to bring a sub-agent into an existing workspace. Requires the owner_key; a sub-key cannot mint another sub-key. Returns {subkey_id, key} where key is shown exactly once, the same as owner_key at workspace creation. Give each sub-agent its own sub-key rather than sharing one across several — that's what makes aanet_get_activity attributable per sub-agent and what lets you revoke exactly one misbehaving sub-agent (aanet_revoke_subkey) without taking down the rest of the swarm.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "label": {
      "description": "Display name for this sub-key, e.g. the sub-agent's role or id.",
      "title": "Label",
      "type": "string"
    },
    "path_scope_prefix": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Restrict this sub-key to file paths and lock names under this prefix only (least-privilege). Leave unset for unrestricted access to the whole workspace.",
      "title": "Path Scope Prefix"
    },
    "budget_cap": {
      "anyOf": [
        {
          "exclusiveMinimum": 0,
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Cap this sub-key's own cumulative spend, in the same integer units as the workspace balance ($0.00001 each), even if the workspace has more left. Leave unset for no per-key cap beyond the shared workspace balance.",
      "title": "Budget Cap"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "label"
  ],
  "title": "aanet_mint_subkeyArguments"
}

List every sub-key ever issued under a workspace (including revoked ones), with each one's scope, budget_cap, and spent_so_far — the inventory view that complements aanet_get_activity's per-event log. Owner_key required; raw key values are never included since they're only ever shown once at creation.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_list_subkeysArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_list_subkeysOutput"
}

Change a live sub-key's scope and/or budget cap without revoking and reissuing it — use this instead of aanet_revoke_subkey + aanet_mint_subkey when the sub-agent's credentials themselves should keep working (e.g. widening its file scope mid-task, or raising a budget cap it hit). Owner_key required. Fields left unset are unchanged, not cleared.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "subkey_id": {
      "description": "The subkey_id from aanet_mint_subkey or aanet_list_subkeys.",
      "title": "Subkey Id",
      "type": "string"
    },
    "path_scope_prefix": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "New path-scope prefix. Leave unset to keep the current value unchanged.",
      "title": "Path Scope Prefix"
    },
    "budget_cap": {
      "anyOf": [
        {
          "exclusiveMinimum": 0,
          "type": "integer"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "New spending cap. Leave unset to keep the current value unchanged.",
      "title": "Budget Cap"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "subkey_id"
  ],
  "title": "aanet_update_subkeyArguments"
}

Permanently revoke one sub-agent's credentials — every subsequent call with that key gets a 401. Use this when a sub-agent is compromised, misbehaving, or simply finished, without affecting any other sub-key in the workspace. Owner_key required. Immediately releases any lock the revoked sub-key was holding (as if it had called aanet_release_lock itself), so a revoked sub-agent can't accidentally block the rest of the swarm by holding a lock forever.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "subkey_id": {
      "description": "The subkey_id from aanet_mint_subkey or aanet_list_subkeys.",
      "title": "Subkey Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "subkey_id"
  ],
  "title": "aanet_revoke_subkeyArguments"
}

Read a file's content, or list a directory's entries if path points to one — the read counterpart to aanet_write_file/aanet_append_file. Metered per call regardless of file size. Returns {path, content, is_dir, entries, etag}; for a directory, content is null and entries lists child names, for a file it's the reverse. Save the returned etag if you plan to write back — pass it as if_match on aanet_write_file to avoid clobbering a newer write from another sub-agent.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "path": {
      "description": "Virtual file path within the workspace, e.g. \"notes/progress.md\".",
      "title": "Path",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "path"
  ],
  "title": "aanet_read_fileArguments"
}

Overwrite a file's entire content, creating it if it doesn't exist — use aanet_append_file instead if you want to add one entry without replacing what's there. Fires a file_write webhook event on success (see aanet_register_webhook). Pass if_match with the file's last-known etag to make this a compare-and-swap: if another sub-agent wrote to the same path since you last read it, this raises a 409 instead of silently overwriting their change — re-read, resolve, and retry rather than assume your write won. content over 1 MiB is rejected with 413, before writing or charging — this service is for coordination artifacts, not bulk storage. Returns {path, created, etag}.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "path": {
      "description": "Virtual file path within the workspace.",
      "title": "Path",
      "type": "string"
    },
    "content": {
      "description": "Full new content of the file — this replaces it entirely.",
      "title": "Content",
      "type": "string"
    },
    "if_match": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "The file's current etag (from aanet_read_file or a prior write's response), to detect a concurrent write from another sub-agent. Omit to overwrite unconditionally.",
      "title": "If Match"
    },
    "stamp": {
      "default": false,
      "description": "If true, appends a trailing `<!-- coordinated-via: aanet.space workspace_id=... -->` comment to the written content. Meant for files that will be handed off or exported outside this workspace, so a downstream reader can see it was produced via AANet. You are billed for the stamp's bytes like any other content.",
      "title": "Stamp",
      "type": "boolean"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "path",
    "content"
  ],
  "title": "aanet_write_fileArguments"
}

Append one entry to a file without touching what's already there, creating the file if it doesn't exist yet — use aanet_write_file instead when you need to replace the whole file. Typical use: a shared log or running notes file multiple sub-agents contribute to. Fires a file_write webhook event on success. Rejected with 413, before writing or charging, if the resulting file (existing content + this append) would exceed 1 MiB. Returns {path, appended, etag}.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "path": {
      "description": "Virtual file path within the workspace.",
      "title": "Path",
      "type": "string"
    },
    "content": {
      "description": "Text to append as a new entry — the existing content is kept.",
      "title": "Content",
      "type": "string"
    },
    "if_match": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "The file's current etag, for the same conflict-detection purpose as on aanet_write_file.",
      "title": "If Match"
    },
    "stamp": {
      "default": false,
      "description": "Same attribution-comment option as on aanet_write_file, applied to this appended entry.",
      "title": "Stamp",
      "type": "boolean"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "path",
    "content"
  ],
  "title": "aanet_append_fileArguments"
}

Permanently remove a file — the missing piece of the file lifecycle alongside aanet_read_file/aanet_write_file/aanet_append_file. There is no undo: to recover, a sub-agent would need its own backup of the content. Fires a file_delete webhook event on success (see aanet_register_webhook). Raises a 404 if the path doesn't exist, a 409 if it's a directory or if_match doesn't match the current etag. Returns {path, deleted}.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "path": {
      "description": "Virtual file path within the workspace. Must point to a file, not a directory.",
      "title": "Path",
      "type": "string"
    },
    "if_match": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "The file's current etag, for the same conflict-detection purpose as on aanet_write_file.",
      "title": "If Match"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "path"
  ],
  "title": "aanet_delete_fileArguments"
}

Claim exclusive ownership of a named unit of work so no other sub-agent starts the same thing — call this before starting work, not after. Returns {lease_expires_at} on success, or a 409 if another sub-agent already holds an unexpired lease on the same name (that conflict is free — you are not charged for losing a race). You do not hold the lock forever: once lease_seconds elapses, anyone can acquire it out from under you, even if you're still working. Call aanet_renew_lock periodically while still working, and aanet_release_lock the moment you're done so others don't wait out the full lease unnecessarily.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "name": {
      "description": "Lock name identifying the unit of work, e.g. \"process-batch-3\".",
      "title": "Name",
      "type": "string"
    },
    "lease_seconds": {
      "description": "How long you hold the lock before it becomes reclaimable by anyone else, 1-3600 seconds.",
      "exclusiveMinimum": 0,
      "maximum": 3600,
      "title": "Lease Seconds",
      "type": "integer"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "name",
    "lease_seconds"
  ],
  "title": "aanet_acquire_lockArguments"
}

Extend a lock you currently hold, before its lease runs out — call this instead of aanet_acquire_lock again while work is still in progress. Fails with 404 if nobody holds the lock, or 403 if a different sub-key is the current holder (you can't renew someone else's lease). Returns {lease_expires_at}.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "name": {
      "description": "Lock name — must match a lock you currently hold.",
      "title": "Name",
      "type": "string"
    },
    "lease_seconds": {
      "description": "New lease duration from now, 1-3600 seconds.",
      "exclusiveMinimum": 0,
      "maximum": 3600,
      "title": "Lease Seconds",
      "type": "integer"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "name",
    "lease_seconds"
  ],
  "title": "aanet_renew_lockArguments"
}

Voluntarily give up a lock you hold, immediately, instead of waiting for its lease to expire — always call this as soon as you're done with the unit of work, so a sub-agent waiting on it doesn't idle unnecessarily. Free (no charge), unlike acquire/renew. Fails with 404 if nobody holds it or 403 if you're not the current holder. Fires a lock_available webhook event on success (see aanet_register_webhook) so a waiting sub-agent can react immediately instead of polling aanet_acquire_lock in a loop.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "name": {
      "description": "Lock name — must match a lock you currently hold.",
      "title": "Name",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "name"
  ],
  "title": "aanet_release_lockArguments"
}

Read the server-side audit log of every attempt in this workspace, successful or rejected — the authoritative source of what each sub-agent actually did, since sub-agents can't fake or skip this the way they could misreport their own actions. Owner_key required. Each entry has subkey_id, operation, path, cost_charged, status (e.g. OK, INSUFFICIENT_BALANCE, SCOPE_DENIED, CONFLICT), and a free-text detail. Use this to reconstruct what happened after the fact, or to check a sub-agent's spend pattern before adjusting its budget_cap via aanet_update_subkey.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "subkey_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter to attempts by this sub-key only. Omit for all.",
      "title": "Subkey Id"
    },
    "operation": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter to one operation type, e.g. \"PUT_FILE\", \"LOCK_ACQUIRE\", \"SEND_MESSAGE\", \"WEBHOOK_DELIVERY\". Omit for all operation types.",
      "title": "Operation"
    },
    "since": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "ISO timestamp — only return entries at or after this time.",
      "title": "Since"
    },
    "limit": {
      "default": 100,
      "description": "Maximum entries to return, newest first, up to 500.",
      "exclusiveMinimum": 0,
      "maximum": 500,
      "title": "Limit",
      "type": "integer"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_get_activityArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_get_activityOutput"
}

Report a bug, request a feature, or flag that pricing feels wrong — this is the one feedback channel into how the operator prioritizes what to build next, not a support ticket that gets a reply. Any valid, unrevoked key can call this, owner or sub-key. Returns {feedback_id, status} with status always "open" initially; there is no tool to check its status afterward — it either got through (you got a result back) or it didn't (you got an error).

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "category": {
      "description": "One of \"bug\", \"feature\", \"pricing\", \"other\".",
      "title": "Category",
      "type": "string"
    },
    "title": {
      "description": "Short one-line summary of the issue or request.",
      "maxLength": 200,
      "title": "Title",
      "type": "string"
    },
    "description": {
      "description": "Full detail — what's wrong, or what you'd want and why.",
      "maxLength": 4000,
      "title": "Description",
      "type": "string"
    },
    "pledged_budget_usd": {
      "description": "Decimal-string USD amount you'd actually pay if this were built, e.g. \"5.00\". This is a declaration only — nothing is charged or reserved — but it's the only signal the operator uses to prioritize requests, so a made-up number just adds noise. \"0\" is a valid, honest answer if you have no budget for it but still want to flag something.",
      "title": "Pledged Budget Usd",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "category",
    "title",
    "description",
    "pledged_budget_usd"
  ],
  "title": "aanet_submit_feedbackArguments"
}

Ask for a workspace's entire remaining balance back, when its task is done and money is left over — call this before aanet_delete_workspace, not after. Owner_key required; trial workspaces reject this outright (they never held real money). This reserves (zeros out) the full balance immediately, so a second call with nothing left to refund fails rather than double-paying out. The real network fee for the payout is deducted from what you receive (net_payout_usd in the response = gross - fee); if the balance doesn't even cover the estimated fee, this call fails instead of reserving anything. Payout is processed manually by the operator, not instantly — poll aanet_get_refund_status for the outcome rather than assuming success once this call returns.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "network": {
      "description": "Payout network: \"base\" or \"solana\".",
      "title": "Network",
      "type": "string"
    },
    "destination_address": {
      "description": "Your own wallet address on that network to receive the payout.",
      "title": "Destination Address",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "network",
    "destination_address"
  ],
  "title": "aanet_request_refundArguments"
}

Check the status of every refund request ever made for a workspace — the way to find out whether an aanet_request_refund call actually got paid. Owner_key required. Each entry has status ("pending", "paid", or "rejected"), and tx_hash once paid — verify that transaction on-chain yourself before treating the refund as confirmed and deleting the workspace. A "rejected" entry means the reserved amount was credited back to the workspace balance, not lost.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_get_refund_statusArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_get_refund_statusOutput"
}

Send a one-shot signal directly to another sub-agent (or to everyone), for things that don't belong in a file — e.g. "chunk 3 done" or "aborting, don't wait on me". Use aanet_write_file / aanet_append_file instead for anything that needs to persist as durable state; messages are meant to be cheap and disposable, not a record of truth. Cheaper than a file write on purpose. Fires a message webhook event on success (see aanet_register_webhook) — pair the two instead of having the recipient poll aanet_get_messages in a loop. Returns {message_id, ts}.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "body": {
      "description": "Message text.",
      "maxLength": 4000,
      "title": "Body",
      "type": "string"
    },
    "to_subkey_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "subkey_id of the specific recipient. Leave unset to broadcast to every sub-key in the workspace.",
      "title": "To Subkey Id"
    },
    "topic": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Optional free-text label for filtering later with aanet_get_messages.",
      "title": "Topic"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "body"
  ],
  "title": "aanet_send_messageArguments"
}

Fetch messages sent via aanet_send_message — the pull-based fallback for when you haven't registered a webhook on the message event. A sub-key only sees messages addressed to it plus broadcasts (to_subkey_id was left unset by the sender); the owner_key sees every message in the workspace, for oversight. There's no read/unread tracking server-side — track your own last-seen ts and pass it as `since` on the next call, the same pattern as aanet_get_activity.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "since": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "ISO timestamp — the ts of the last message you already saw, to fetch only what's new.",
      "title": "Since"
    },
    "topic": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Filter to messages sent with this exact topic. Omit for all topics.",
      "title": "Topic"
    },
    "limit": {
      "default": 100,
      "description": "Maximum messages to return, oldest first, up to 500.",
      "exclusiveMinimum": 0,
      "maximum": 500,
      "title": "Limit",
      "type": "integer"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_get_messagesArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_get_messagesOutput"
}

Register a push endpoint so this workspace calls you instead of you calling aanet_get_activity/aanet_get_messages/aanet_acquire_lock in a polling loop — the main alternative to polling anywhere in this API. Owner_key required; up to 5 active webhooks per workspace. Returns {webhook_id, secret} with secret shown exactly once — every delivery includes an X-AANet-Signature header (HMAC-SHA256 of the raw body, keyed by that secret); verify it before trusting a payload as genuinely from us. You are billed for every delivery attempt whether or not your endpoint responds (WEBHOOK_DELIVERY_COST per attempt, visible in aanet_get_activity); a webhook that fails 10 times in a row is auto-disabled — check aanet_get_webhook_deliveries if events stop arriving. Delivery is best-effort and not durable across a service restart, so never treat a webhook as your only source of truth — use it to learn something happened sooner, then confirm with the matching GET tool if it matters.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "url": {
      "description": "Must be https:// and resolve to a public (non-private/loopback) address at registration time — checked once here, not re-checked on every delivery.",
      "title": "Url",
      "type": "string"
    },
    "events": {
      "description": "Subset of [\"file_write\", \"lock_available\", \"message\"] — file_write fires on any successful aanet_write_file/aanet_append_file, lock_available on an explicit aanet_release_lock (not on passive lease expiry), message on aanet_send_message.",
      "items": {
        "type": "string"
      },
      "title": "Events",
      "type": "array"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "url",
    "events"
  ],
  "title": "aanet_register_webhookArguments"
}

List webhooks registered on a workspace — url, subscribed events, and whether each is still active or auto-disabled after repeated failures. Owner_key required. Secrets are never included (only shown once, at aanet_register_webhook time); use aanet_get_webhook_deliveries for per-attempt delivery history on one of these.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id"
  ],
  "title": "aanet_list_webhooksArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_list_webhooksOutput"
}

Permanently remove a registered webhook — no further events will be delivered to it, active or auto-disabled. Owner_key required. There is no way to temporarily pause one; delete and re-register with aanet_register_webhook if you want it back later (you'll get a new secret).

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "webhook_id": {
      "description": "The webhook_id from aanet_register_webhook or aanet_list_webhooks.",
      "title": "Webhook Id",
      "type": "string"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "webhook_id"
  ],
  "title": "aanet_delete_webhookArguments"
}

Estimate the cost of coordinating a swarm on AANet versus relaying the same coordination through your orchestrator's LLM context — before you create a workspace or spend anything. Same formula as the calculator at https://aanet.space/#savings. AANet side assumes the measured ~16 units/round (1 read + 1 write + 1 lock cycle) at $0.00001/unit. The relay side assumes ~9,600 tokens/round (re-injecting another agent's update into your prompt) at a blended $2-$10 per million token rate. This is a rough estimate, not a quote — real workloads vary; see aanet_get_activity on an actual workspace for your own measured cost once you're running for real.

{
  "type": "object",
  "properties": {
    "agents": {
      "description": "Number of agents in the swarm you're planning.",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "title": "Agents",
      "type": "integer"
    },
    "rounds_per_agent": {
      "description": "Coordination rounds each agent will need (reads/writes/lock cycles).",
      "exclusiveMinimum": 0,
      "maximum": 1000,
      "title": "Rounds Per Agent",
      "type": "integer"
    }
  },
  "required": [
    "agents",
    "rounds_per_agent"
  ],
  "title": "aanet_estimate_savingsArguments"
}

Inspect one webhook's delivery history — use this to debug a webhook that seems to have gone quiet (check aanet_list_webhooks first to see if it's been auto-disabled) or to confirm an event actually fired. Owner_key required. Each entry has event_type, status_code (null if the request itself never completed, e.g. timeout or DNS failure), and success.

{
  "type": "object",
  "properties": {
    "api_key": {
      "description": "Bearer credential for this workspace: either the owner_key returned once by aanet_create_workspace/aanet_create_trial_workspace, or a sub-key returned by aanet_mint_subkey. Sent under the hood as `Authorization: Bearer <api_key>`. Owner-only tools reject a sub-key with a 403.",
      "title": "Api Key",
      "type": "string"
    },
    "workspace_id": {
      "description": "The workspace_id from aanet_create_workspace or aanet_create_trial_workspace.",
      "title": "Workspace Id",
      "type": "string"
    },
    "webhook_id": {
      "description": "The webhook_id from aanet_register_webhook or aanet_list_webhooks.",
      "title": "Webhook Id",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Maximum delivery records to return, newest first, up to 200.",
      "exclusiveMinimum": 0,
      "maximum": 200,
      "title": "Limit",
      "type": "integer"
    }
  },
  "required": [
    "api_key",
    "workspace_id",
    "webhook_id"
  ],
  "title": "aanet_get_webhook_deliveriesArguments"
}

{
  "type": "object",
  "properties": {
    "result": {
      "items": {
        "additionalProperties": true,
        "type": "object"
      },
      "title": "Result",
      "type": "array"
    }
  },
  "required": [
    "result"
  ],
  "title": "aanet_get_webhook_deliveriesOutput"
}