Ellipsis llms.txt

The actual file

Source Markdown

The saved llms.txt text, displayed as source. The file belongs to its publisher; the live endpoint may change.

Showing the first 18000 characters. Load the complete file to read the remainder.

# 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

Managed Agent Platform for Software Factories, Code Review, and Background Agents, for Any Model and Any Harness

Run agents on managed infrastructure. You choose the harness, model, and tools. We'll handle the VM's, permissions, budgets, and logs.

Your agent. Our infrastructure. Build your own workflows using our cloud platform.

- Agents in YAML — Define the prompt, environment, permissions, and budget in YAML.
- Claude Code and Codex — Switch between Claude Code and Codex by changing one block of YAML.
- Spending limits — Limits per session, day, week, and month.
- Session records — Follow sessions live and keep every command, tool call, and code change.

Three ways teams use Ellipsis. Coding agents, code review, and background agents.

- Software factories — Every coding agent in YAML, run in the cloud. (https://www.ellipsis.dev/use-cases/software-factories)
- Code review — Reviewers you define review every push. (https://www.ellipsis.dev/use-cases/code-review)
- Background agents — Start an agent with one API call. (https://www.ellipsis.dev/use-cases/background-agents)

## /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 or GPT 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-review — Use cases: For Code Review

Ultra-custom Code Review

Build a review pipeline around your codebase. Configure reviewers with their own instructions and models, give them your project environment, and decide which pull requests they review and what they can spend.



## /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.
- [Getting started](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, the