ellipsis.dev

# Ellipsis

Ellipsis is a cloud platform for coding agents. You define an agent in a YAML file in your repository and deploy it with git push. Each session runs on its own isolated cloud machine with your repositories cloned in and credentials scoped below any developer's, started by GitHub events, Slack and Linear mentions, Sentry alerts, or a schedule, and it opens pull requests with its work. Which harness and model it runs is a config field; the sandboxes, the permissions, the hard per-session and monthly spend caps, and the recorded transcript of every step are the platform underneath. Everything is reachable from the REST API, the `ellipsis` CLI, and the Python and TypeScript SDKs.

The Ellipsis skill teaches any coding agent to use this product in depth:

    npx skills add ellipsis-dev/cli

Its source is https://github.com/ellipsis-dev/cli/blob/main/skills/ellipsis/SKILL.md

- Full text of all documentation: https://www.ellipsis.dev/llms-full.txt
- Any single docs page as markdown: append `.md` to its URL, e.g. https://www.ellipsis.dev/docs/agents/schema.md
- Complete OpenAPI specification of the REST API: https://www.ellipsis.dev/openapi.v1.json
- Python SDK: https://pypi.org/project/ellipsis-dev/ (`pip install ellipsis-dev`, imports as `ellipsis`)
- TypeScript SDK: https://www.npmjs.com/package/@ellipsis-dev/sdk

# Website Content (https://www.ellipsis.dev)

One section per page, headed by its URL path.

## / — Homepage

The Platform for Your Software Factory

Build your own coding agents for feature generation, background tasks, and code review.
We'll handle the infrastructure, permissions, logging, and budgets.

### /#cloud-agents — Interactive Sessions

FREE FOR INDIVIDUALS

Cloud sessions feel like local but they give you an isolated cloud environment with your repositories, dependencies, and tools ready. No more git worktree conflicts.

Learn more: https://www.ellipsis.dev/use-cases/development

### /#agents — From YAML to API

Define agents in YAML, deploy with a merge, and run them through API calls, schedules, or events.

Learn more: https://www.ellipsis.dev/platform/agents

agent.yaml

```yaml
ellipsis:
  name: dependency-updates
trigger:
  type: cron
  schedule: "0 9 * * 1"
session:
  claude_code:
    prompt: |
      Update dependencies in web-repo.
      Run tests and open a pull request.
  environment:
    repositories:
      - name: web-repo
    hooks:
      after_checkout: |
        cd web-repo
        pnpm install --frozen-lockfile
    compute:
      cpu: 4
      memory: 8GB
  budget:
    session: 5
```

Put agents into your apps and workflows

Start sessions through REST or the Python and TypeScript SDKs. Connect agents to your tools and data, then inspect their work in Ellipsis.

- API — Start sessions, follow their progress, and retrieve results through REST or the Python and TypeScript SDKs.
- Web — Start sessions and inspect their messages, tool calls, and results in Ellipsis.
- Terminal — Start and steer cloud sessions from your terminal.
- Slack — Ask an agent to investigate, read its findings, and follow up in the same thread.
- GitHub — Investigate issues, review changes, and open pull requests from your repository workflows.

How it Works Set up an environment for your agent, spawn sessions, observe every token.

- Define Agents in YAML — Pick your repositories, install dependencies, and set environment variables. Choose your coding agent, scope its permissions, and set spending limits. [Learn about Environments](https://www.ellipsis.dev/platform/environments)
- Spawn Sessions — Run agents in isolated cloud environments with your code and tools ready. Automate repeatable work on schedules or in response to events. [Learn about Sessions](https://www.ellipsis.dev/platform/sessions)
- Observe Logs — Follow sessions live and inspect every step, tool call, and result. Access full agent logs and track costs and activity across your team. [Learn about Observability](https://www.ellipsis.dev/platform/observability)

Secure, Managed Infrastructure that is very easy to use

Ellipsis is built with governance at scale in mind. Permissions are defined before a session starts. Every agent action is logged. You have full control over your data longevity. SOC 2 Type I: Certified. SOC 2 Type II: In progress.

- Scoped credentials — Minted per session, scoped to the repos you allowed, revoked with the sandbox.
- Zero source retention — Your code lives only in the session sandbox and is deleted with it.
- Full audit trail — Every command, file change, and tool call an agent made, kept after the sandbox is gone.

## /platform — Platform

Agents-as-a-Service

Run agents in isolated cloud environments with scoped permissions, budget controls, and logs for every run.

## /platform/agents — Platform: Agents

Reusable coding agents

Save an agent’s instructions and settings, then run it on demand, on a schedule, or from events.

- Define once, run repeatedly — Save the prompt, agent, environment, permissions, and budget in YAML.
- Deploy with a merge — Review changes in a pull request and merge to make them live.
- Choose when agents run — Call an agent through the API, set a schedule, or connect an event trigger.

## /platform/sessions — Platform: Sessions

Cloud Agent Sessions

Work with Claude Code and Codex in isolated cloud environments, with your repositories, dependencies, and tools ready. Run sessions in parallel and steer each agent as it works.

- Run tasks in parallel — Give each task its own cloud machine, without competing for laptop resources.
- Skip repeated setup — Reuse prepared environments with your repositories, dependencies, and tools.
- Keep working with your laptop closed — Agents continue running in the cloud after you disconnect.

## /platform/environments — Platform: Environments

Reusable Cloud Environments

Define the repositories, dependencies, services, and tools your agents need. Reuse the same setup across sessions and agents.

- Run your actual project — Give agents the code, dependencies, and services they need to build and test your changes.
- Save setup time — Cache installed dependencies in an image so each session starts without rebuilding from scratch.
- Share setup across your team — Keep environment configuration in git so developers and agents use the same setup.

## /platform/handlers — Platform: Handlers

Build Your Own Internal Agents

Configure agents for Slack, GitHub, Linear, and Sentry in YAML, with your instructions, repositories, and tools ready to handle messages, mentions, and alerts.

- Configure an agent in one file — Use slack.yaml, github.yaml, linear.yaml, or sentry.yaml to set instructions and response rules.
- Give it a custom environment — Choose repositories, dependencies, services, and tools so the agent can build and test your code.
- Deploy with a merge — Merge the configuration and let incoming messages, mentions, or alerts start the work.

## /platform/secrets — Platform: Secrets

Secret Management for Agents

Manage credentials through the API and reference them in agent environments. Ellipsis supplies the stored values when sessions run.

- Manage secrets programmatically — Create, update, list, and delete secrets through the API.
- Control which credentials agents receive — Select secrets by name in each environment’s configuration.
- Update credentials centrally — Replace a secret once, and future sessions use the new value wherever it’s referenced.

## /platform/webhooks — Platform: Webhooks

Session Webhooks

Connect Ellipsis to your systems with signed notifications when agent sessions are created.

- Build agents into your workflows — Use session notifications to update your application’s records and trigger your own processes.
- Verify every notification — Check signed payloads to confirm requests came from Ellipsis.
- Handle delivery failures — Automatic retries handle temporary failures. Delivery history shows response codes and errors.

## /platform/models — Platform: Models

Pick the model per agent

Choose Claude, GPT, or open models while keeping your team’s environments, integrations, permissions, and session history in one platform.

- Change models without rebuilding workflows — Select a different supported model for new sessions while reusing your existing setup.
- Keep your existing subscriptions — Connect Claude or ChatGPT subscriptions to cover token usage for eligible sessions.
- Choose who bills for model usage — Use Ellipsis credits or your Claude or ChatGPT subscription.

## /platform/observability — Platform: Observability

Every session is recorded

Follow agent work live, inspect what happened, and track usage across your team. Keep the complete session record for debugging and analysis.

- Understand what an agent did — Inspect its conversation, commands, tool results, and code changes.
- See where your budget goes — Track costs and token usage by session, developer, and agent.
- Analyze logs in your own tools — Retrieve session records through the API or download unmodified Claude Code and Codex output.

## /platform/security — Platform: Security

Define agent permissions as code

Give each agent the access its task requires, instead of your personal credentials. Scope repository access and read or write permissions for each session.

- Limit access to your repositories — Choose which repositories agents can access and whether they can read or write.
- Isolate each session — Run agent code in a separate cloud machine, away from developer laptops and other sessions.
- Revoke credentials automatically — Ellipsis revokes the GitHub credentials it creates for a session when its sandbox is torn down.

## /platform/budgets — Platform: Budgets

Hard spend caps for every agent

Set budgets for individual tasks, developers, agents, and your whole team.

- Limit each session’s spend — Set a session budget to stop further model requests when the limit is reached.
- Allocate budgets across your team — Give developers and agents separate limits within your account’s overall budget.
- Control recurring costs — Apply rolling daily, weekly, and monthly limits across repeated sessions.

## /use-cases — Use cases

What teams put agents to work on

The same platform, a different job on each page. Ship changes from an issue to a pull request, answer questions where your team already works, and put the recurring work on a schedule.

## /use-cases/development — Use cases: For Development

Move Agent Work to the Cloud

Run coding agents on cloud machines with your project’s dependencies, services, and tools ready. Start independent tasks in parallel, keep your laptop free, and let agents continue working after you disconnect.



## /use-cases/background-agents — Use cases: For Background Agents

Background Agents as YAML

Write the instructions, choose the tools, and set the limits in YAML. Ellipsis runs your agents in the cloud so your applications can delegate work, track progress, and collect results.



## /use-cases/code-migrations — Use cases: For Code Migrations

One Migration Plan. Parallel Agents

Apply shared instructions across independent tasks, each with its own cloud session and project environment. Track the work centrally and review each agent’s changes before bringing them into your codebase.



## /use-cases/agent-swarms — Use cases: For Agent Swarms

Run Fifty Agents at Once

Start independent tasks in parallel, each on its own cloud machine with your project setup ready. Use the API to assign work, track sessions, and collect results, with permissions and budgets for each task.



## /use-cases/slack — Use cases: Code Changes from Slack

Build a Custom Slack Agent

Give your team an agent with access to your code, project environments, and connected tools. Configure its behavior and budget in YAML, then start tasks through Slack mentions and continue in the same conversation.



## /use-cases/linear — Use cases: Code Changes from Linear

Assign Linear Issues to Agents

Mention an agent on a Linear issue and it starts a session with the issue as its task. It works in your project environment, opens a pull request, and replies on the issue.



## /use-cases/sentry — Use cases: Bug Fixes from Sentry

Fix Errors When Sentry Alerts

A Sentry alert starts an agent with the event context. It reproduces the failure in your project environment, opens a pull request with the fix, and comments on the Sentry issue.



## /use-cases/software-factories — Use cases: For Software Factories

Primitives for your Software Factory

Define reusable agent workflows in YAML and connect them to your company’s tools. Ellipsis runs the work in prepared cloud environments, with shared permissions, budgets, and session records that stay in place as you change supported agents and models.



## /integrations — Integrations

Agents that start where the work already is

An agent is only useful where your team already works. Connect the tools you use and an event there starts a session, with the agent reading and writing back in the same place.

## /integrations/github — Integrations: GitHub

Run Agents from GitHub Events

Install the GitHub App and agents react to pull requests, pushes, and issues, and answer @ellipsis mentions in any thread. Each session gets a token minted for it, narrowed to the repositories and permissions named in YAML, so nothing in the sandbox can exceed what you granted.

- Repository events start the work — An agent declares one event surface and the filters that scope it: a pull request opened against your default branch that touches migrations, a push to a release branch, an issue with a given label. Work starts the moment the event fires.
- Mention @ellipsis where the review is happening — Mention @ellipsis in a pull request or issue comment and an agent picks the thread up as its prompt. Replies continue the same conversation with no repeat mention, so a review comment becomes a fix without anyone leaving the pull request.
- A token per session, scoped in YAML — No agent runs on a developer's credentials. Each sandbox gets its own installation token that lives an hour and dies at teardown, narrowed to the repositories and permission scopes the config names. GitHub mints it with that scope, so the limit holds even against a prompt injection.

## /integrations/linear — Integrations: Linear

Turn a Linear Issue into a Pull Request

Connect your workspace and a new issue can start an agent that implements it and opens a pull request linked back to the ticket. A session that adds the Linear tools can read, create, and update issues, and @ellipsis on an issue gets an answer in the comments.

- A new issue starts the work — One trigger block and a filed issue becomes a running agent. The ticket your team already wrote is the prompt, so nobody translates a description into instructions before the work can begin.
- From ticket to pull request without a relay — The agent reads the issue, works the problem in its own sandbox, opens a pull request linked back to the ticket, and comments what it did. The issue moves because the agent moved it.
- Agents read and write Linear directly — Linear is not just the trigger. Any session that adds the Linear tools can read issues and comments, update fields, move statuses, and file new issues, so a nightly audit lands in your backlog instead of a log nobody opens.

## /integrations/slack — Integrations: Slack

Start an Agent from a Slack Thread

Mention @ellipsis in a channel or DM the bot, and an agent picks the conversation up as its prompt and answers in the thread. Configure your responder for the channels and DMs you choose, and let any session that adds the Slack tools post its results back to Slack.

- Ask in the channel, get the work back there — A mention starts a durable conversation in that thread, and replies continue it without mentioning again. The question, the answer, and the pull request it turned into all sit in the same place your team was already discussing it.
- Configure your Slack responder — One slack.yaml in your .ellipsis repository defines your responder, with its repositories, model, prompt, permissions, and budget. Choose the channels and DM authors it answers; other conversations use the built-in responder.
- Every agent can post back to Slack — Slack is an output, not only an input. Any session that adds the Slack tools can read a channel for context and post its result where the team reads, so a nightly job's findings arrive as a message on Monday morning instead of sitting in a log.

## /integrations/sentry — Integrations: Sentry

Start an Investigation from an Alert

An issue or metric alert starts an agent that pulls the event context, works the failure in a sandbox, and comments its diagnosis back on the Sentry issue.



Not available yet: Jira (/integrations/jira).

## /agents — Agents

Pick the coding agent your team already uses

Any harness, any model: Ellipsis is the infrastructure under whichever agent wins. The sandboxes, the credentials, the budgets, and the logs stay the same while the agent and the model are config fields.

- Claude (/agents/claude)
- Codex (/agents/codex)
- Copilot (/agents/copilot) — not available yet
- Gemini (/agents/gemini) — not available yet
- Cursor (/agents/cursor) — not available yet
- Grok Code (/agents/grok) — not available yet
- Antigravity (/agents/antigravity) — not available yet
- OpenCode (/agents/opencode) — not available yet
- Pi (/agents/pi) — not available yet

## /compare — Compare

How Ellipsis compares to running agents yourself

Both pages below start from an agent you already run: on your laptop, or wired into a workflow file. Each one is the same agent, and the difference is everything around it.

- vs Claude on a laptop (/compare/ellipsis-vs-claude-on-laptop) — The same agent, running without you at the terminal
- vs Claude on GitHub Actions (/compare/ellipsis-vs-claude-on-github-actions) — What a workflow file leaves you to build yourself

# Docs

- [Authentication](https://www.ellipsis.dev/docs/api/authentication): Create an API key and authenticate requests.
- [API overview](https://www.ellipsis.dev/docs/api): Start agent sessions and manage agents with the CLI, Python, TypeScript, or curl.
- [Python SDK](https://www.ellipsis.dev/docs/api/python-sdk): Start sessions, stream records, and invoke agents from Python.
- [Quick start](https://www.ellipsis.dev/docs/api/quick-start): Start your first agent session from the CLI, Python, TypeScript, or curl.
- [Session events](https://www.ellipsis.dev/docs/api/session-events): Every modeled session event, with JSON examples for platform, harness, and streaming consumers.
- [TypeScript SDK](https://www.ellipsis.dev/docs/api/typescript-sdk): Start sessions, stream records, and invoke agents from TypeScript.
- [Budgets](https://www.ellipsis.dev/docs/budgets): Cap what each session, agent, and your whole account can spend.
- [Ellipsis](https://www.ellipsis.dev/docs): Run internal agents in the cloud with Claude Code or Codex, and extend them with your own tools, secrets, and MCP servers.
- [Models](https://www.ellipsis.dev/docs/models): Choose a model and connect your Claude or ChatGPT subscription.
- [Account settings](https://www.ellipsis.dev/docs/organization): Configure spend limits and record retention.
- [Permissions](https://www.ellipsis.dev/docs/permissions): Limit the GitHub and Ellipsis operations a session can perform.
- [Pricing](https://www.ellipsis.dev/docs/pricing): Understand credits, model usage, sandbox charges, and automatic recharge.
- [Quick start](https://www.ellipsis.dev/docs/quick-start): Set up Ellipsis for your repository.
- [Secrets](https://www.ellipsis.dev/docs/secrets): Store tokens and keys once, then use them in environments and MCP servers without putting them in git.
- [Security](https://www.ellipsis.dev/docs/security): Data deletion SLAs, retention limits, and controls for repository and secret access.
- [Support](https://www.ellipsis.dev/docs/support): Contact Ellipsis and check service status.
- [Webhooks](https://www.ellipsis.dev/docs/webhooks): Get a signed HTTPS request whenever a session is created.
- [Environments](https://www.ellipsis.dev/docs/environments): Set the repositories, setup scripts, and environment variables a session starts with.
- [Environment schema reference](https://www.ellipsis.dev/docs/environments/schema): Complete environment examples and field reference.
- [Claude Code](https://www.ellipsis.dev/docs/harnesses/claude): Models, options, and features for Claude Code.
- [Codex](https://www.ellipsis.dev/docs/harnesses/codex): Models, options, and features for Codex.
- [Harnesses](https://www.ellipsis.dev/docs/harnesses): Claude Code and Codex, the two coding agents Ellipsis runs.
- [Code review](https://www.ellipsis.dev/docs/agents/code-review): Review each push to a pull request with an agent you write.
- [Agents](https://www.ellipsis.dev/docs/agents): Save a task and its session settings, then start it on demand, on a schedule, or from events.
- [Agent schema reference](https://www.ellipsis.dev/docs/agents/schema): Complete agent examples, typed inputs and outputs, and field reference.
- [Triggers](https://www.ellipsis.dev/docs/agents/triggers): Run agents on schedules or matching events.
- [GitHub](https://www.ellipsis.dev/docs/integrations/github): Connect repositories and configure the handler for GitHub mentions.
- [Integrations](https://www.ellipsis.dev/docs/integrations): Connect your tools.
- [Linear](https://www.ellipsis.dev/docs/integrations/linear): Connect Linear, answer Ellipsis mentions on issues, and give sessions Linear tools.
- [Sentry](https://www.ellipsis.dev/docs/integrations/sentry): Start an investigation when a Sentry alert fires, configured with sentry.yaml.
- [Slack](https://www.ellipsis.dev/docs/integrations/slack): Connect Slack, answer @ellipsis mentions, and give sessions Slack tools.
- [Sessions](https://www.ellipsis.dev/docs/sessions): Start a coding task, follow it, send follow-ups, and review the changes.
- [Lifecycle](https://www.ellipsis.dev/docs/sessions/lifecycle): Read a session's conversation and turn, and know when the message you sent is answered.
- [Get budget](https://www.ellipsis.dev/docs/api/account/get-account-budget): Read account and developer spend limits and current usage.
- [List models](https://www.ellipsis.dev/docs/api/account/get-account-models): List supported models, harnesses, capabilities, and token prices.
- [Get usage](https://www.ellipsis.dev/docs/api/account/get-account-usage): Read usage for a UTC calendar month. Rated subscription usage is separate from actual Ellipsis credit charges.
- [Account](https://www.ellipsis.dev/docs/api/account): Account endpoints describe the resources available to your agents. Check budgets, inspect usage, and list available models.
- [Delete an agent](https://www.ellipsis.dev/docs/api/agents/delete-agents-agent_id): Delete an API-managed agent. Existing session history remains available.
- [Get agent usage](https://www.ellipsis.dev/docs/api/agents/get-agents-agent_id-metrics): Read usage and spend windows for an agent.
- [Get an agent](https://www.ellipsis.dev/docs/api/agents/get-agents-agent_id): Read a saved agent and its configuration source.
- [List agents](https://www.ellipsis.dev/docs/api/agents/get-agents): List saved agents.
- [Agents](https://www.ellipsis.dev/docs/api/agents): Agents define repeatable agent work. Create and update configurations, connect them to GitHub, start sessions, and inspect usage.
- [Link to GitHub](https://www.ellipsis.dev/docs/api/agents/post-agents-agent_id-link): Open a pull request containing the definition. Git takes ownership when that pull request merges and syncs.
- [Start an agent session](https://www.ellipsis.dev/docs/api/agents/post-agents-agent_id-sessions): Start a session from a saved agent. The body takes the fields of Start a session, all optional: each field you send replaces the agent value for that field, and each field you leave out keeps it. Send input when the agent declares an input schema.
- [Unlink from GitHub](https://www.ellipsis.dev/docs/api/agents/post-agents-agent_id-unlink): Make the agent API-managed. Its repository file stops controlling the definition.
- [Create an agent](https://www.ellipsis.dev/docs/api/agents/post-agents): Create an API-managed agent. It is live immediately.
- [Update an agent](https://www.ellipsis.dev/docs/api/agents/put-agents-agent_id): Replace an API-managed agent definition. Edit git-managed definitions in their repository or unlink them first.
- [Delete an environment](https://www.ellipsis.dev/docs/api/environments/delete-environments-environment_id): Delete an API-managed environment. New sessions referencing it will fail.
- [Get an environment](https://www.ellipsis.dev/docs/api/environments/get-environments-environment_id): Read an environment definition.
- [List environments](https://www.ellipsis.dev/docs/api/environments/get-environments): List saved environments.
- [Environments](https://www.ellipsis.dev/docs/api/environments): Environments define where agents run. Create reusable configurations, inspect saved environments, and update or remove them.
- [Create an environment](https://www.ellipsis.dev/docs/api/environments/post-environments): Create an API-managed environment. Sessions can reference its name or ID.
- [Update an environment](https://www.ellipsis.dev/docs/api/environments/put-environments-environment_id): Replace an API-managed environment definition. Git-managed definitions must be edited in their repository.
- [Get handler metrics](https://www.ellipsis.dev/docs/api/handlers/get-handlers-handler_id-metrics): Read session counts by current status and accumulated cost for a saved handler. Optional start and end timestamps filter session creation time, including start and excluding end. Cost includes the selected sessions' full history, in millicents. Requires configs:read matching handlers/{service} and unrestricted sessions:read.
- [List handlers](https://www.ellipsis.dev/docs/api/handlers/get-handlers): List the account's synced Slack, GitHub, Linear, and Sentry handlers. Disabled handlers and the last valid definitions after failed syncs are included. Requires configs:read; scoped grants match handlers/{service}.
- [Handlers](https://www.ellipsis.dev/docs/api/handlers): Handlers define how agents respond to events. Discover your handlers and inspect their activity and usage.
- [List repositories](https://www.ellipsis.dev/docs/api/integrations/get-integrations-github-repos): List repositories available through the GitHub installation.
- [List integrations](https://www.ellipsis.dev/docs/api/integrations/get-integrations): Read connected integrations and their settings.
- [Integrations](https://www.ellipsis.dev/docs/api/integrations): Integrations connect your account to external services. List connections and discover GitHub repositories available to your agents.
- [Get identity](https://www.ellipsis.dev/docs/api/platform/get-identity): Read the account and identity associated with the credential.
- [Identity](https://www.ellipsis.dev/docs/api/platform): Identity describes the account and credentials behind a request. Inspect the identity associated with your API token.
- [Delete a secret](https://www.ellipsis.dev/docs/api/secrets/delete-secrets-name): Delete a stored secret. New sessions that require it will fail.
- [List secret names](https://www.ellipsis.dev/docs/api/secrets/get-secrets): List secret names and metadata. Values are never returned.
- [Secrets](https://www.ellipsis.dev/docs/api/secrets): Secrets supply credentials to agent environments. Set values, list stored names, and remove credentials you no longer need.
- [Set secrets](https://www.ellipsis.dev/docs/api/secrets/put-secrets): Store secret values for environments to reference. Values cannot be read back.
- [Search sessions](https://www.ellipsis.dev/docs/api/sessions/get-sessions-search): Search session history. Supply q and filter by service, handler, or source.
- [Get changes](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-diff): Read the changes produced by a session.
- [Download a transcript](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-download): Download the session transcript.
- [Get commits and pull requests](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-git): Read commits and pull requests associated with a session.
- [Get structured output](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-output): Read the validated JSON result of a session with an output schema.
- [List records](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-records): Read complete platform and native harness records. Partial text deltas are live-only.
- [Get a turn](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-turns-turn_id): Read one turn. Poll it after sending a message: the message is answered when the turn status is completed, failed, stopped, or cancelled.
- [List turns](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id-turns): Read every turn and message of a session, oldest first. A turn is pending until the agent starts on it, running while it works, then completed, failed, stopped, or cancelled.
- [Get a session](https://www.ellipsis.dev/docs/api/sessions/get-sessions-session_id): Read a session: its conversation, current turn, cost, and settings.
- [List sessions](https://www.ellipsis.dev/docs/api/sessions/get-sessions): List sessions with filters for time, source, service, handler, agent, and attribution.
- [Sessions](https://www.ellipsis.dev/docs/api/sessions): Sessions run agents in the cloud. Start work, send follow-up messages, inspect progress, and retrieve transcripts, changes, and structured output.
- [Send a message](https://www.ellipsis.dev/docs/api/sessions/post-sessions-session_id-messages): Send a follow-up to a conversation. The response carries the message and the turn that answers it; a message sent while a turn runs is answered after it. Reuse an idempotency key when retrying the same message.
- [Stop a session](https://www.ellipsis.dev/docs/api/sessions/post-sessions-session_id-stop): Stop the turn in progress. The turn ends stopped and the conversation stays open; the recorded history remains available.
- [Start a session](https://www.ellipsis.dev/docs/api/sessions/post-sessions): Start a cloud session. Select a harness explicitly. Provide an inline environment, reference a saved environment, or omit it to use the default environment. Set conversation.interactive to false to run once. The response carries the turn that answers the prompt.
- [Delete a webhook](https://www.ellipsis.dev/docs/api/webhook-endpoints/delete-webhooks-webhook_id): Delete a webhook and cancel outstanding deliveries.
- [Get a delivery](https://www.ellipsis.dev/docs/api/webhook-endpoints/get-webhooks-deliveries-delivery_id): Inspect the event payload and delivery attempts.
- [List deliveries](https://www.ellipsis.dev/docs/api/webhook-endpoints/get-webhooks-deliveries): List recent deliveries and their statuses.
- [Get a webhook](https://www.ellipsis.dev/docs/api/webhook-endpoints/get-webhooks-webhook_id): Read a webhook endpoint and its state. The signing secret is not returned.
- [List webhooks](https://www.ellipsis.dev/docs/api/webhook-endpoints/get-webhooks): List webhook endpoints and activation states.
- [Webhooks](https://www.ellipsis.dev/docs/api/webhook-endpoints): Webhooks send events to your application. Configure destinations, send test events, and inspect delivery attempts.
- [Send a test event](https://www.ellipsis.dev/docs/api/webhook-endpoints/post-webhooks-webhook_id-ping): Send a signed webhook.ping. The receiver must return HTTP 200.
- [Create a webhook](https://www.ellipsis.dev/docs/api/webhook-endpoints/post-webhooks): Create a session-event webhook. Save the signing secret returned once in this response. Verify the initial ping, then request activation through Support.
- [Update a webhook](https://www.ellipsis.dev/docs/api/webhook-endpoints/put-webhooks-webhook_id): Update a webhook. Changing its URL resets verification and approval and sends a new ping.