Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Jobs HTTP Endpoint, 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%2Fsanity.io%2Fsanity-jobs" | 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%2Fsanity.io%2Fsanity-jobs" | 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 Jobs HTTP Endpoint API.
Check a Sanity job's state, such as pending, running, completed, or failed, by its job ID
See which author IDs started a job and when it was created and last updated
Stream live job events with a progress value from 0 to 100 until the job reaches a terminal state
Detect stream problems through channel_error and disconnect events, including an unknown job ID
Patterns agents use Jobs HTTP Endpoint API for, with concrete tasks.
GET STARTED
★ AI agent waiting on a dataset copy
An agent that clones a production dataset into staging before testing needs to know when the copy is done. Through Jentic it searches for 'check a Sanity job status', loads the job status operation, and polls it with the job ID returned by the copy request while the Sanity token is injected at call time. When the state reads completed it moves on; failed or terminated means it stops and reports.
Call GET /jobs/{jobId} for job jacsfsmnxp every 30 seconds until state is completed, failed, or terminated, then report the final state and updated_at
Live progress display for long jobs
A deploy script or dashboard can show a job's progress instead of polling. The listen endpoint keeps a server-sent events stream open, sending job events with the current state and a progress percentage, and closes after a final event with progress 100 once the job ends. Streams are capped at 12 hours, after which a channel_error and disconnect event are sent.
Open GET /jobs/{jobId}/listen for job jacsfsmnxp and log each job event's state and progress until the stream closes
Failed job triage
When a scheduled dataset copy does not land, the first question is what happened and who ran it. The job status response carries the final state, the author IDs that started the job, and its created_at and updated_at timestamps, so an agent can report a failed or terminated job with when it stopped and who to contact.
Call GET /jobs/{jobId} for job jacsfsmnxp and, if state is failed or terminated, report the authors, created_at, and updated_at values
2 endpoints — the sanity jobs api reports on long-running processes inside sanity's infrastructure, such as dataset copy jobs.
METHOD
PATH
DESCRIPTION
/jobs/{jobId}
Get a job's status
/jobs/{jobId}/listen
Stream job status and progress events
/jobs/{jobId}
Get a job's status
/jobs/{jobId}/listen
Stream job status and progress events
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the Sanity Jobs API by hand means templating the apiVersion into the host, sending a bearer token, and handling a server-sent events stream whose errors arrive as events rather than HTTP status codes. Through Jentic you install once, import it from the API Directory, store the token once, and your agent calls it.
Permission scoping
Sanity puts the job ID in the URL path (/jobs/{jobId}), so a rule can pin your agent to one job. Both operations are reads, so the agent can follow a job but cannot start, change, or cancel anything through this API.
Credential isolation
Your Sanity 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 'check a Sanity job status' or 'wait for a dataset copy to finish', and Jentic returns the jobStatus or jobListen operation with its path parameter.
Alternatives and complements available in the Jentic catalogue.
Specific to using Jobs HTTP Endpoint API through Jentic.
What authentication does the Sanity Jobs API use?
Per its OpenAPI spec, the Sanity Jobs API uses a bearer token in the Authorization header, and both the status and listen calls return 401 without a valid one. Through Jentic the Sanity token is stored by your own instance and attached at call time, so it stays out of the agent's context.
What job states can the Sanity Jobs API return?
The status response lists the state as pending, running, completed, failed, terminating, or terminated. The listen stream treats completed, failed, terminating, and terminated as terminal: it sends a final job event with progress 100 and closes.
How long can a Sanity job listen stream stay open?
The spec says a channel_error event is sent when the stream has been open for 12 hours, followed by a disconnect event before it closes. If the job is deleted while you are listening, the stream closes without sending an event, so fall back to the status call.
What are the rate limits for the Sanity Jobs API?
The OpenAPI spec does not specify rate limits. Check the Sanity documentation at https://www.sanity.io/docs for current API limits for your plan.
Is there a Sanity MCP server?
You don't need an MCP server to give your agent the Sanity Jobs API. Jentic connects it directly from the API Directory: import it, store your Sanity token once, and your agent calls the job status or listen operation when it needs to wait on a job.
How do I check a Sanity job's status through Jentic?
Search Jentic for 'check a Sanity job status', load the job status operation, and execute GET /jobs/{jobId} with the ID returned when the job was started. To run it on your own infrastructure, install Jentic One from its GitHub repo.
Can I limit what my agent is allowed to do with the Sanity Jobs API?
Yes. Write a rule that allows only GET /jobs/jacsfsmnxp and its listen stream, and the agent can follow that one copy job without seeing any other job on the account. Every call it makes is logged.
For Agents
Check the state of a Sanity background job such as a dataset copy, or stream its progress from 0 to 100 until it completes or fails.
Use for: Check whether my dataset copy job has finished, Get the status of job jacsfsmnxp, Monitor the progress of the staging copy until it completes, I want to know if the copy job failed
Not supported: Does not start, cancel, or retry jobs, and does not copy datasets itself. Use for reading the status and progress of Sanity background jobs only.
The Sanity Jobs API reports on long-running processes inside Sanity's infrastructure, such as dataset copy jobs. A status call returns a job's id, its state (pending, running, completed, failed, terminating, or terminated), the author IDs behind it, and its created and updated timestamps. A listen stream sends a welcome event, then job events carrying the state and a progress value from 0 to 100, and closes with a final event once the job reaches a terminal state. Errors after the stream opens, such as an unknown job ID or a stream open for 12 hours, arrive as channel_error and disconnect events rather than HTTP status codes.
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>