Сторонний удостоверяющий прокси-сервер — получите независимое криптографическое доказательство для любого HTTP-вызова.
Работает с AI-агентами, вебхуками, микросервисами или любым HTTP-клиентом. Доказательство подписывается ArkForge (независимой третьей стороной), а не вызывающей стороной.
Получите бесплатный API-ключ (500 доказательств/месяц) →
Когда система выполняет HTTP-вызов, не существует независимой записи о том, что было отправлено, что получено или когда это произошло. Любая из сторон может отрицать или изменить транзакцию.
ArkForge решает эту проблему, выступая в качестве удостоверяющего прокси: вызывающая сторона направляет свой запрос через ArkForge, который подписывает полный пакет «запрос+ответ» ключом Ed25519, ставит метку времени согласно RFC 3161 и фиксирует его в Sigstore Rekor — неизменяемом, публично проверяемом журнале.
Полученное доказательство постоянно доступно для проверки по публичному URL-адресу кем угодно, без необходимости обращения к ArkForge.
В этом разница между самоподписанным сертификатом и сертификатом, выданным центром сертификации (CA). Другие инструменты создают доказательства, подписанные самой вызывающей стороной. ArkForge создает доказательства, подписанные независимой третьей стороной.
Related MCP server: AGA-mcp-server
AI-агенты — контрольный журнал для каждого внешнего вызова API (Claude, GPT, Mistral, LangChain, AutoGen)
Вебхуки — доказательство того, что событие Stripe или GitHub было получено с именно этим полезным контентом (payload)
Микросервисы — защищенный от несанкционированного доступа журнал между внутренними сервисами (соответствие требованиям, финтех)
Поставщики данных — доказательство того, что внешний API вернул это значение в этот момент времени
Автоматизация — сертификация действий в рабочих процессах n8n или Zapier
{
"mcpServers": {
"arkforge": {
"command": "uvx",
"args": ["arkforge-mcp"],
"env": {
"ARKFORGE_API_KEY": "your_api_key_here"
}
}
}
}Получите бесплатный API-ключ (500 доказательств/месяц) на сайте arkforge.tech.
certify_callНаправьте HTTP-вызов через ArkForge и получите криптографическое доказательство транзакции.
target URL of the upstream API to call
payload JSON body (optional)
method "POST" or "GET" (default: "POST")
description Human-readable description included in the proof
agent_identity Identifier for the calling system (optional)Возвращает proof_id, verification_url, upstream_response, chain_hash, timestamp и signature (Ed25519).
Используйте это вместо прямого вызова API, когда вам нужна проверяемая запись.
Пример ответа:
{
"proof_id": "prf_20260310_143022_a1b2c3",
"verification_url": "https://trust.arkforge.tech/v1/proof/prf_20260310_143022_a1b2c3",
"upstream_response": { "status": "ok" },
"chain_hash": "e3b0c44298fc1c149afb...",
"timestamp": "2026-03-10T14:30:22.481Z",
"timestamp_authority": "verified",
"rekor_log_id": "https://rekor.sigstore.dev/api/v1/log/entries/...",
"seller": "api.example.com",
"signature": "MCowBQYDK2VwAyEA..."
}get_proofПолучение полного пакета доказательств для заданного proof_id.
verify_proofПолучение краткого изложения того, что удостоверяет доказательство — полезно для объяснения пользователю или аудитору, что именно было независимо проверено.
get_usageПроверка оставшихся кредитов на текущий месяц.
Поле | Описание |
| Уникальный идентификатор — постоянный публичный URL |
| SHA-256 точного отправленного запроса |
| SHA-256 точного полученного ответа |
| Комбинированный хеш — защита от несанкционированного доступа |
| Домен вызываемого API |
| Метка времени RFC 3161 через FreeTSA (QTSP eIDAS в версии Enterprise) |
| Запись в неизменяемом журнале Sigstore Rekor |
| Подпись Ed25519 независимым ключом ArkForge |
План | Доказательств/месяц | Цена |
Free | 500 | 0 € |
Pro | 5 000 | 29 €/мес |
Enterprise | 50 000 + QTSP eIDAS | 149 €/мес |
MCP-сервер — это один из способов интеграции. Тот же API работает с любого языка или фреймворка:
curl -X POST https://trust.arkforge.tech/v1/proxy \
-H "X-Api-Key: your_key" \
-H "Content-Type: application/json" \
-d '{"target": "https://api.example.com/action", "payload": {"data": "value"}}'Call an external API and get a cryptographic proof of the transaction.
Use this INSTEAD of calling the API directly when you need an auditable, tamper-evident record of what was sent and received.
The proof is signed by ArkForge (independent third party), timestamped via RFC 3161, and anchored in Sigstore Rekor — not self-signed by your agent.
Args: target: URL of the upstream API to call (e.g. "https://api.example.com/v1/action") payload: JSON body to send to the upstream API (optional for GET requests) method: HTTP method — "POST" or "GET" (default: "POST") description: Human-readable description of what this call does (included in the proof) agent_identity: Identifier for the calling agent (optional, included in the proof)
Returns: JSON with proof_id, verification_url, the upstream API response, chain_hash, and timestamp. Share verification_url with any third party to let them independently verify what happened.
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | ||
| payload | No | ||
| method | No | POST | |
| description | No | ||
| agent_identity | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively explains key traits: it calls an external API, generates a signed proof by ArkForge (third-party), includes timestamping and anchoring, and returns verification details. However, it lacks information on error handling, rate limits, or authentication needs for the target API, leaving some gaps in behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, followed by usage guidelines, parameter explanations, and return details. Every sentence adds value—no redundancy or fluff—and it efficiently covers necessary information in a compact format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (external API calls with proof generation), no annotations, and an output schema present, the description is highly complete. It explains the purpose, usage context, parameters, and return values in detail, compensating for the lack of annotations and leveraging the output schema to avoid over-explaining returns. This suffices for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for all parameters: target is the 'URL of the upstream API', payload is the 'JSON body to send', method specifies 'HTTP method', description is 'Human-readable description', and agent_identity is an 'Identifier for the calling agent'. This clarifies usage beyond basic schema titles, though it doesn't detail format constraints (e.g., URL validation).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Call an external API and get a cryptographic proof of the transaction.' It specifies the verb ('call'), resource ('external API'), and unique outcome ('cryptographic proof'), distinguishing it from sibling tools like get_proof, get_usage, and verify_proof, which focus on retrieving or verifying proofs rather than creating them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: 'Use this INSTEAD of calling the API directly when you need an auditable, tamper-evident record of what was sent and received.' This provides clear guidance on the alternative (direct API calls) and the specific context (need for proof), helping the agent choose correctly among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve the full cryptographic proof for a given proof ID.
Returns the complete proof bundle: request/response hashes, parties, RFC 3161 timestamp, Sigstore Rekor log entry, and archive.org snapshot.
Args: proof_id: The proof identifier (e.g. "prf_20260310_143022_a1b2c3")
| Name | Required | Description | Default |
|---|---|---|---|
| proof_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what the tool returns (complete proof bundle with specific components) which is valuable context beyond the input schema. However, it doesn't mention performance characteristics, error conditions, authentication requirements, or rate limits, which would be helpful for a retrieval operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured: a clear purpose statement followed by return value details, then parameter documentation. Every sentence earns its place with zero waste. The information is front-loaded with the core functionality stated first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which handles return value documentation) and only one parameter, the description provides adequate context. It explains what the tool does, what it returns, and documents the parameter with an example. For a simple retrieval tool, this is reasonably complete, though additional behavioral context would improve it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate. It provides a clear explanation of the single parameter ('proof_id') including its purpose and an example format ('prf_20260310_143022_a1b2c3'), adding significant meaning beyond the bare schema. The example format helps users understand the expected input pattern.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Retrieve') and resource ('full cryptographic proof for a given proof ID'), distinguishing it from siblings like 'certify_call' (create), 'get_usage' (usage stats), and 'verify_proof' (validation). The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by specifying 'for a given proof ID', suggesting this tool is for retrieving existing proofs rather than creating or verifying them. However, it doesn't explicitly state when to use this versus alternatives like 'verify_proof' or provide exclusion criteria, leaving some ambiguity about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check your ArkForge API usage and remaining credits for the current period.
Returns your tier (Free / Pro / Enterprise), proofs used, proofs remaining, and the reset date.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what the tool returns (tier, proofs used, proofs remaining, reset date), which is helpful. However, it doesn't mention critical behavioral traits like whether this is a read-only operation, if it requires authentication, or any rate limits. The description adds some value but leaves gaps in behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, consisting of two sentences that efficiently convey the tool's purpose and return values. Every sentence adds value without unnecessary details, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is reasonably complete. It explains what the tool does and what it returns, which is sufficient for a simple read operation. However, it could be more complete by addressing authentication or usage context, especially since no annotations are provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The baseline for this scenario is 4, as the description appropriately focuses on the tool's purpose and output without redundant parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check your ArkForge API usage and remaining credits for the current period.' It specifies the verb ('check') and resource ('API usage and remaining credits'), making it easy to understand what the tool does. However, it doesn't explicitly distinguish itself from sibling tools like 'certify_call', 'get_proof', or 'verify_proof', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, such as authentication requirements, or compare it to sibling tools. The only implied usage is checking API usage, but there's no explicit context for when this is necessary or appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a human-readable summary of what a proof certifies.
Useful for explaining to a user or auditor what was independently verified, without reading raw JSON.
Args: proof_id: The proof identifier (e.g. "prf_20260310_143022_a1b2c3")
| Name | Required | Description | Default |
|---|---|---|---|
| proof_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the output is 'human-readable' and summarizes verification details, which adds value beyond the schema. However, it lacks details on permissions, rate limits, or error handling, leaving behavioral gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by usage context and parameter details. Every sentence earns its place with no wasted words, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers purpose, usage, and parameter semantics well. However, with no annotations, it could benefit from more behavioral details like authentication or error scenarios, slightly reducing completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains that 'proof_id' is 'The proof identifier' and provides an example format ('e.g. "prf_20260310_143022_a1b2c3"'), clarifying the parameter's purpose and expected syntax, fully compensating for the schema's lack of documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get a human-readable summary') and resource ('what a proof certifies'), distinguishing it from sibling tools like 'get_proof' (which likely returns raw data) and 'certify_call' (which creates proofs). The purpose is explicit and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: 'Useful for explaining to a user or auditor what was independently verified, without reading raw JSON.' This implies it should be used for human consumption rather than programmatic access. However, it does not explicitly state when not to use it or name alternatives like 'get_proof'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0certify_callget_proofget_usageverify_proofScored across 4 tools
Each tool has a distinct and non-overlapping purpose: certify_call creates proofs, get_proof retrieves raw proof data, get_usage checks account status, and verify_proof provides human-readable summaries. There is no ambiguity about when to use which tool, as they target different stages of the proof lifecycle and administrative functions.
All tools follow a consistent verb_noun pattern with clear, descriptive names: certify_call, get_proof, get_usage, and verify_proof. The naming is uniform, using snake_case throughout, and the verbs (certify, get, verify) accurately reflect the actions without mixing conventions.
With 4 tools, this server is well-scoped for its purpose of providing cryptographic proof and verification services. Each tool serves a clear role in the workflow—creating, retrieving, verifying proofs, and managing usage—without being overly sparse or bloated, making it efficient for agents to navigate.
The tool set covers the core lifecycle of proof creation, retrieval, and verification, along with administrative usage checks. A minor gap exists in the lack of tools for managing or deleting proofs, but this does not hinder basic operations, and agents can still perform essential tasks without dead ends.
Attestation infrastructure for the agentic economy: signed, independently verifiable verdicts.
Issue signed receipts for AI agent actions; verify any receipt offline - free, no account.
Zero-trust gateway for AI agents: score tool calls, verify agent cards, enforce policy, audit.
Signed attestations for agents, $0.01/call via x402: URL witness, AI permission, tx finality, JWKS.
