Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Hands for Agents API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fhandsforagents.com%2Fhandsforagents" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fhandsforagents.com%2Fhandsforagents" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
What an agent can do with Hands for Agents API.
List available services, refused categories, and example prices
Request a fixed-price quote for a physical task and check its status
Upload input files to a quote and list what has been uploaded
Accept a quote to create a task and receive a Stripe Checkout link
Confirm delivery of a completed task or open a dispute
GET STARTED
Patterns agents use Hands for Agents API for, with concrete tasks.
★ Quote to Delivery Workflow
An agent runs a physical task from request to delivery. It sends the task for human screening, receives a fixed-price quote, uploads any input files, accepts the quote to create a task with a Stripe Checkout link, then confirms delivery once the item arrives. Because quotes and tasks are separate resources with their own status, the agent can poll each stage and keep its operator informed.
Request a quote for a described physical task, accept it to create a task, and return the Stripe Checkout link
File-Backed Quoting
An agent attaches the drawings or specs a human needs to price a job accurately. It requests a quote, uploads one or more input files to that quote, and lists the uploaded files to confirm they arrived before a person screens the request. This keeps the quoting conversation grounded in real inputs rather than a text description alone.
Create a quote, upload a drawing file to it, and list the files on the quote to confirm the upload
Delivery Confirmation and Disputes
An agent closes the loop after a task ships. It reads the task status, confirms delivery when the item matches the brief, or opens a dispute when it does not. Running confirmation through the API gives the operator an auditable record of acceptance tied to the paid task.
Read a task's status and confirm delivery, or open a dispute if the delivered item does not match the brief
12 endpoints — the hands for agents api lets an ai agent commission a person in the eu to design, make, assemble, measure, test, verify, or ship a physical thing, then pay for it and track it to delivery.
METHOD
PATH
DESCRIPTION
/services
List services, refused categories, and example prices
/quotes
Send a task for screening and a fixed-price quote
/quotes/{quote_id}
Get the status of a quote
/quotes/{quote_id}/files
Upload input files to a quote
/tasks
Accept a quote and get a Stripe Checkout link
/tasks/{task_id}/delivery-confirmation
Confirm delivery or open a dispute
/services
List services, refused categories, and example prices
/quotes
Send a task for screening and a fixed-price quote
/quotes/{quote_id}
Get the status of a quote
/quotes/{quote_id}/files
Upload input files to a quote
/tasks
Accept a quote and get a Stripe Checkout link
/tasks/{task_id}/delivery-confirmation
Confirm delivery or open a dispute
What agents get from Jentic-routed access to this vendor.
Setup
Wiring Hands for Agents by hand means handling its bearer task token, knowing which endpoints are open and which need the token, and following a quote through screening, payment, and delivery. Through Jentic you install once, import it from the API Directory, store the token once, and your agent calls it.
Permission scoping
Hands for Agents carries quote and task ids in the URL path, so a rule can pin your agent to the quote and task operations for one task. You choose the operations it may call, so steps like delivery confirmation or opening a dispute are not included unless you add them.
Credential isolation
Your Hands for Agents task token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'request a quote for a physical task' or 'confirm delivery', and Jentic returns the matching operation with its input schema so the agent calls the right endpoint without reading the reference docs.
Alternatives and complements available in the Jentic catalogue.
Specific to using Hands for Agents API through Jentic.
What authentication does the Hands for Agents API use?
Per its OpenAPI spec, task and quote-status operations authenticate with a bearer task token in the Authorization header, while a few endpoints are open: listing services, requesting a quote, recovering a lost access token, and opening a payment link. Through Jentic the task token is stored by your own self-hosted instance and injected when the agent calls a protected operation, so it never appears in the agent's prompt or logs.
Can I commission a physical task with the Hands for Agents API?
Yes. An agent lists the available services, sends a task for human screening to get a fixed-price quote, uploads any input files, then accepts the quote to create a task and receive a Stripe Checkout link. After the item ships, the agent confirms delivery or opens a dispute, and the operator is invoiced by a registered EU company.
What are the rate limits for the Hands for Agents API?
The OpenAPI spec does not state a numeric rate limit. Add retry and backoff around 429 responses when polling quote and task status, and check the Hands for Agents documentation at https://handsforagents.com for any published limits.
Can I limit what my agent is allowed to do with the Hands for Agents API?
Yes. Write a rule that allows the quote and task read and create operations for one task id, so the agent can request and track a job without reaching the delivery-confirmation or dispute operations until you add them, and every call it makes is logged. Hands for Agents carries quote and task ids in the URL path, which is what makes that per-task boundary possible.
Is there a Hands for Agents MCP server?
You do not need an MCP server to give your agent the Hands for Agents API. Jentic connects it directly from the Jentic API Directory: import Hands for Agents, store your task token once, and your agent calls the quote and task operations on demand without loading another server's tool definitions into its context.
How do I commission a task with the Hands for Agents API through Jentic?
Search Jentic by intent such as 'request a quote for a physical task', and Jentic returns the Hands for Agents operation with its input schema so the agent sends the right fields. To run it on your own infrastructure, install Jentic One from its GitHub repo with `curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh`, then add Hands for Agents from the directory.
For Agents
Commission a person to make, assemble, test, or ship a physical thing: list services, request a fixed-price quote, upload files, accept and pay via a Stripe Checkout link, and confirm delivery.
Use for: Request a quote to have a part machined and shipped, List the services and refused categories before I send a task, Check the status of a quote I submitted, Upload a drawing to an existing quote
Not supported: Does not handle open-ended project management, team collaboration, or recurring subscriptions. Use for requesting quotes and commissioning fixed-price physical tasks only.
The Hands for Agents API lets an AI agent commission a person in the EU to design, make, assemble, measure, test, verify, or ship a physical thing, then pay for it and track it to delivery. An agent lists the available services, sends a task for human screening and a fixed-price quote, uploads input files, accepts a quote to create a task with a Stripe Checkout link, and confirms delivery or opens a dispute. The agent's operator receives an invoice from a registered EU company.
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
Base layer of spec validity and structural soundness.
Aggregated quality score from linter diagnostics, weighted by severity.
Percentage of `$ref` references that resolve successfully.
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
Structural correctness score based on schema issues using logarithmic dampening.
Clarity, completeness, and ingestion readiness for developers and tooling.
How richly the API is illustrated with examples.
Percentage of examples that conform to their schemas.
Percentage of operations with complete response definitions (success, client error, server error).
Health of API ingestion, bundling, and resolution within Jentic pipelines.
Semantic breadth, depth, and agent comprehension for AI systems.
Coverage of descriptions across API elements.
Coverage of RFC 9457 Problem Details for error responses.
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
Coverage of summaries across operations/tags/info.
Functional utility, complexity comfort, and AI orchestration readiness.
Agent comfort level based on API operational and structural complexity.
Trust, risk posture, and security compliance.
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
Findability, semantic richness, and reasoning readiness.
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>