canonical: https://jentic.com/apis/atako.ai/atako

# Atako API

The Atako API creates and runs AI agents, letting you provision an agent, set the language model it runs on, write its instructions and role, and then chat with it over conversations and messages. Each agent can be given files from a company drive, connected to external API and tool integrations, placed on a team, and assigned work through projects, cards, and a wiki. The API also exposes the model catalog, bring-your-own LLM keys, billing and subscriptions, and a company dashboard with an audit log of what every agent did.

## For AI agents

Create AI agents, choose their model, write their instructions, chat with them, and grant them files and integrations. Authenticates with a bearer token, either an aik_ API key or a session JWT.

## Scope

Does not train or host the underlying language models, run your own servers, or replace your LLM provider account. Use for creating, configuring, and operating Atako AI agents and their workspace only.

## Capabilities

- Create and provision AI agents and set their model, role, and instructions
- Open conversations with an agent and send it chat messages
- Steer or stop an agent's running turn and read its live activity
- Give an agent files from a company drive through file grants
- Connect external API and tool integrations and grant them to an agent
- Organize agents and people into teams, projects, and boards

## Use cases

### Agent-of-Agents Orchestration

An AI agent connected through Jentic provisions an Atako agent, sets its model and instructions, opens a conversation, and sends it work, so one agent can stand up and supervise another. Because turns can be steered or stopped mid-run, the controlling agent can correct a task without waiting for it to finish.

Example prompt: Create an agent on a chosen model, write its instructions, then send it a first task message and read its reply

### File-Grounded Agent Work

A team uploads documents to the company drive and grants specific files to an agent so it works only from approved material. File grants and the agent's dedicated folder keep the agent's working set explicit rather than giving it the whole drive.

Example prompt: Upload a document to the drive and grant it to this agent, then confirm the agent can read it

### Integration-Connected Agents

An operator connects an external API or tool integration and grants it to an agent, so the agent can act in another system under a scoped grant. The integration grant can be updated or revoked, which keeps the agent's reach adjustable over time.

Example prompt: Connect an integration, grant it to the agent, and later revoke the grant on request

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/agents` | Create an agent |
| GET | `/agents` | List your agents |
| POST | `/agents/{agentId}/messages` | Send a chat message to an agent |
| PATCH | `/agents/{id}/model` | Change a live agent's model |
| POST | `/agents/{agentId}/file-grants` | Grant files to an agent |
| GET | `/models/catalog` | List the available model catalog |

## Key resources

- **Agents** — AI agents with model, role, instructions, conversations, activity, and lifecycle controls
- **Files and grants** — A company drive plus file grants that scope which files an agent can read
- **Integrations** — External API and tool connections and the grants that give an agent access
- **Projects and teams** — Boards, cards, wiki pages, teams, and org structure for organizing agents and people

## AI readiness

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.

- **Score:** 50 / 100
- **Maturity:** Non-Ready
- **Dimensions:**
  - Foundational Compliance: 40 / 100
  - Developer Experience & Jentic Compatibility: 63 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 43 / 100
  - Security: 60 / 100
  - AI Discoverability: 71 / 100
- **View full report:** https://jentic.com/apis/atako.ai/atako/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Atako API by hand means minting an aik_ API key (or carrying a session JWT), learning which operations a read key cannot call, and sorting the public content endpoints from the authenticated ones. Through Jentic you install once, import Atako from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Atako puts the agent, project, and team ids in the URL path, so a rule can pin your agent to one Atako agent or project and let it send messages and read activity while leaving billing, API-key management, and account deletion out. You choose the operations it may call, so destructive ones like deleting an agent are not included unless you add them.
- **Credential handling:** Your Atako key 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.
- **Discovery method:** Agents search Jentic by intent such as 'create an agent' or 'send a message to an agent', and Jentic returns the matching Atako operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **CrewAI API** — Framework and platform for orchestrating multi-agent AI crews
- **Relevance AI API** — Platform for building and running AI agents and agent teams
- **OpenAI API** — Chat, embeddings, and model APIs for building on large language models

## FAQ

### Is there an Atako MCP server?

Yes. Atako runs its own MCP server and can also connect external MCP servers as agent integrations. You can connect the Atako API directly through Jentic instead: your agent gets the full 274-endpoint surface without loading another server's tool definitions into its context, your key is injected at call time by your self-hosted instance instead of living in a config file, and your rules decide which operations the agent may call.

### Can I limit what my agent is allowed to do with the Atako API?

Yes. Write a rule that allows sending messages and reading activity for one Atako agent but not deleting agents, changing billing, or managing API keys, so the agent can operate a workspace without touching the account, and every call it makes is logged. Because the agent and project ids are in the URL path, you can bound the agent to a single agent or project.

### What authentication does the Atako API use?

The Atako API authenticates with a bearer token, either an aik_ programmatic API key created in Settings or a session JWT, per its OpenAPI spec. A read-scoped key is restricted to GET operations, and some account actions are reserved to a signed-in user. Through Jentic the key is stored encrypted by your own instance and added at call time, so it never appears in the agent's prompt or logs.

### Can I create and run an AI agent with the Atako API?

Yes. You create an agent, set its model from the available catalog, write its instructions and role, then open a conversation and send it messages, with its running turns steerable or stoppable. The same agent can be given files and integrations so it has what it needs to do the work.

### What are the rate limits for the Atako API?

The OpenAPI spec does not specify rate limits for the Atako API. For current limits and quota details, see the Atako documentation at https://atako.ai.

### How do I create and run an Atako agent through Jentic?

Import the Atako API from the Jentic API Directory, then have your agent issue a request such as 'create an agent on this model and send it a task'. Jentic matches the intent to the create-agent and send-message operations and returns their input schemas so the agent builds the right calls, with your stored key injected at call time. To run it on your own infrastructure, install Jentic One from its GitHub repo.