Download Jin skills for your AI agents.
Make your agent tooling agent-ready with the official Jin skill package. Ship a reusable AIP integration that agents can discover, validate, and execute through `jin.json` intent maps.
Why use Jin skills?
Jin skills let AI agents consume a structured intent surface instead of scraping UI. This reduces errors, improves safety, and unlocks deeper automation across apps.
- Download a GitHub-first integration package for agent builders.
- Use already-curated intent map patterns for modern agents.
- Keep your app discoverable with a standard AIP skill workflow.
Agent consumption flow
Agents can use Jin to discover your app via `.well-known/jin.json`, parse intent definitions, and invoke APIs with typed parameters. The official skill repo contains examples, helpers, and runtime guidance.
The integration package is designed for any developer building AI agent tooling, wrappers, or connectors around Jin AIP.
{
"aip_version": "0.1",
"app": {
"name": "My App",
"description": "Expose intent definitions for AI agents",
"url": "https://myapp.com"
},
"auth": {
"type": "bearer"
},
"intents": [
{
"id": "create_invoice",
"name": "Create invoice",
"description": "Generate an invoice for a customer",
"triggers": ["create an invoice", "generate invoice"],
"method": "POST",
"endpoint": "/api/invoices",
"parameters": {
"customer_id": { "type": "string", "required": true },
"amount": { "type": "number", "required": true }
}
}
]
}Download the repo
Clone or download the official Jin skill package from GitHub.
Connect your agent
Use the repo examples to wire your agent runtime to Jin AIP discovery and execution.
Publish your intent map
Serve `/.well-known/jin.json` and make your app reachable by every modern agent.
Download Jin Skills
Copy or download these skill definitions to integrate Jin AIP into your agent framework.
skill.json
Agent skill definition for Jin AIP
{
"type": "function",
"function": {
"name": "execute_jin_protocol",
"description": "Discovers and executes actions on a target website using the Jin Agent Intent Protocol (AIP). Always use this tool first when a user asks to interact with a specific web application or API.",
"parameters": {
"type": "object",
"properties": {
"target_url": {
"type": "string",
"description": "The base URL of the application the user wants to interact with (e.g., https://api.open-meteo.com)."
},
"user_intent": {
"type": "string",
"description": "The natural language description of what the user wants to accomplish on the site (e.g., 'Get the current weather for Tokyo')."
},
"provided_parameters": {
"type": "object",
"description": "Any specific data points or parameters the user provided in their prompt that should be passed to the intent.",
"additionalProperties": true
}
},
"required": ["target_url", "user_intent"]
}
}
}skill.xml
Agent skill definition for Jin AIP
<jin_aip_protocol>
<objective>
You are equipped with "Jin," a universal Agent Intent Protocol (AIP) for interacting with web applications. When tasked with performing an action on a website, you MUST attempt to use its native API via the `jin.json` intent map before falling back to UI scraping, browser automation, or web search.
</objective>
<standard_operating_procedure>
<step sequence="1" name="Discovery">
Make an HTTP GET request to `[target_url]/.well-known/jin.json`.
If 200 OK: Proceed to step 2.
If 404 Not Found or timeout: Abort Jin protocol and fallback to standard automation behaviors.
</step>
<step sequence="2" name="Parsing_and_Matching">
Analyze the `intents` array in the response. Evaluate the `description` and `triggers` (natural language phrases) for each intent to match the user's requested task to the correct intent ID.
</step>
<step sequence="3" name="Safety_and_Authorization">
Inspect the matched intent's flags:
- requires_auth: If true, check root `auth` object. Request credentials from the user if missing.
- destructive: If true, this action modifies/deletes data. You MUST halt and ask the user for explicit confirmation.
- confirmation_required: If true, summarize the pending action to the user and wait for approval.
</step>
<step sequence="4" name="Execution">
Construct the HTTP request using the intent's `method` and `endpoint`. Map the user's data to the required `parameters`, ensuring correct `type` and satisfying all `required` fields. Execute the request.
</step>
</standard_operating_procedure>
<schema_reference version="0.1">
{
"aip_version": "string",
"app": { "name": "string", "description": "string", "url": "string" },
"auth": { "type": "none|bearer|oauth2|apikey" },
"intents": [{
"id": "string",
"name": "string",
"description": "string",
"triggers": ["string"],
"category": "string",
"method": "string",
"endpoint": "string",
"parameters": {
"param_name": { "type": "string", "required": boolean }
},
"requires_auth": boolean,
"destructive": boolean,
"confirmation_required": boolean
}],
"published": "ISO8601-Date"
}
</schema_reference>
</jin_aip_protocol>Usage
Add skill.json to your agent's function schema or tool registry.
Use skill.xml as agent instructions or system prompt guidance for Jin AIP protocol behavior.
For full source code and examples, visit the GitHub repository.