# Ara

> Ara is an autonomous software engineer for GitHub. Connect a repository, assign
> issues, and Ara's cloud agents open evidence-backed pull requests (with screen
> recordings, logs, and review-ready diffs). People drive Ara from the web app at
> https://ara.so; programmatic per-user access is available through the HTTP API.

If you are an AI agent: use the public HTTP API below instead of scraping this
website.

## HTTP API

- Base URL: `https://api.ara.so`
- Auth: `Authorization: Bearer <ara_api_key>`
- Credential check: `GET /v3/self`
- Workspace scope: use `/v3/organizations/:orgId/*`, where `:orgId` can be the
  workspace id or slug.
- Health: `GET https://api.ara.so/healthz`
- All responses are JSON.
- Quickstart: https://docs.ara.so/api-quickstart
- Full endpoint reference: https://docs.ara.so/api-reference

## Start and monitor a session

Create a session with `POST /v3/organizations/:orgId/sessions`:

```json
{
  "prompt": "Fix the flaky auth test, add a regression case, and open a PR.",
  "repo": "acme/web",
  "provider": "github",
  "idempotency_key": "one-stable-key-per-logical-run"
}
```

- `prompt` is required and must be non-empty.
- `repo` and `provider` are optional. Omit them for a repository-neutral scratch
  session; do not substitute a repository ID field.
- `idempotency_key` is an optional JSON body field, not an HTTP header. Reuse the
  same value when retrying the same logical create request.
- A new create returns HTTP 201. An idempotent replay returns HTTP 200 with the
  original session. Both return `session_id`, `url`, and `status`.
- Poll `GET /v3/organizations/:orgId/sessions/:sessionId`. Status is `running`,
  `exit` (completed successfully), `error`, or `suspended` (cancelled/quota).
  Only `exit` is successful. The retrieved session's nullable `pr_url` is the
  pull or merge request URL when one exists; it is not part of the create response.

## Common endpoints

```
GET  /v3/organizations                                # list workspaces
POST /v3/organizations/:orgId/sessions                # start an Ara session
GET  /v3/organizations/:orgId/sessions                # list sessions
GET  /v3/organizations/:orgId/sessions/:sessionId     # retrieve a session
POST /v3/organizations/:orgId/sessions/:sessionId/messages  # send a follow-up
GET  /v3/organizations/:orgId/repositories            # list enabled repositories
GET  /v3/organizations/:orgId/git-plugins             # list GitHub plugins
```

## Notes

- This file lives at https://ara.so/llms.txt and is the canonical machine-readable
  entry point for agents. Read it first.

## Pages

Every page below is also available as clean Markdown: append `.md` to the URL, or send `Accept: text/markdown`. The entire site as one file: https://ara.so/llms-full.txt

### Product

- [Get Ara](https://ara.so/download.md): Ara for Mac, the terminal, and the browser. Sign in once and your sessions follow you.

### Company

- [Notes from the software factory.](https://ara.so/blog.md): Product updates, engineering deep-dives, and how teams ship with Ara.
- [Changelog](https://ara.so/news.md): What's new in Ara: features, fixes, and infrastructure.
- [Contact Ara](https://ara.so/contact.md): Get in touch with the Ara team.
- [Enterprise-grade control. Coding agent built for software teams.](https://ara.so/pricing.md): Start with Ara in minutes, then scale verified engineering across your organization—without adding a per-seat tax.
- [Building the future of coding.](https://ara.so/about.md): Coding is changing from a craft practiced one prompt at a time into an operating system for building.
- [One conversation. Verified pull requests.](https://ara.so/yc.md): Ara is a YC P26 company. Current and alumni YC companies redeem $25,000 in Ara credits through Bookface, then put their codebase on autopilot. Talk to Main, let children do the work in isolated workspaces, and get every change back with evidence.

### Blog

- [Rust harness wars: grok-build vs codex](https://ara.so/blog/rust-harness-wars.md): We cloned xAI's grok-build and OpenAI's codex and read both line by line, twenty subsystems each, to see where two labs building the same coding agent actually diverge.
- [From issue runs to software factories](https://ara.so/blog/from-issue-runs-to-software-factories.md): How Ara shapes the loop from incoming signal to a verified PR and updated repo memory.
- [The discipline of an agent run](https://ara.so/blog/the-discipline-of-an-agent-run.md): Why capable agents need a clear assignment, a bounded environment, and evidence that a human can review.

### Enterprise

- [Autonomous engineering inside your perimeter.](https://ara.so/enterprise.md): Ara ships verified pull requests in your cloud, under your controls, with a signed record on every run. Start on one repo and expand as the evidence stacks up.

### Use cases

- [Turn every alert into a closed loop](https://ara.so/use-cases/operations.md): Ara watches the systems you run, triages each signal against the playbook, and acts. What used to page a human at 3am now opens a verified pull request instead.
- [From issue to verified pull request, one context.](https://ara.so/use-cases/engineering.md): Ara reads the issue, reproduces it in an isolated workspace, writes the fix, and verifies it before asking for review. The whole sdlc runs in a single thread of context.
- [Point a question at the repo. Get a cited answer.](https://ara.so/use-cases/research.md): Ara runs an agentic research pass over a codebase or problem, traces the real call paths, and reports findings with a citation behind every claim. Each run also writes back what it learned, so the next one starts smarter.