# 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.

## 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.
- [Every software task gets a live session.](https://ara.so/product/sessions.md): Start from a prompt, issue, or repo question. Ara provisions the workspace, streams the work, verifies the change, and hands back the transcript and pull request.
- [Connect local machines and coding tools to Ara](https://ara.so/product/cli.md): Sign in once, enroll this Mac as an Ara Device, and configure supported coding tools without creating a second session system.
- [Work on Web & Mobile without break](https://ara.so/product/web-mobile.md): Start a run from the web app, watch it execute live, and clear review gates from your phone. The factory floor follows you off the desk.
- [Ship pull requests without leaving Slack.](https://ara.so/product/slack.md): Trigger runs from a thread, watch each stage stream back in-channel, and approve sensitive actions where your team already works.
- [Your backlog ships itself](https://ara.so/product/jira-linear.md): Move an issue to the right status and ara reproduces the bug, writes the fix, verifies it, and opens a reviewed pull request. The ticket walks itself to review.

### Automations

- [Continuous cloud agents for the work that should not wait.](https://ara.so/product/automations.md): Schedule audits, wire event triggers, and let Ara open verified fixes when the same engineering work repeats across repos.
- [One place to review every pull request Ara touches.](https://ara.so/product/review.md): Review turns PRs, checks, comments, and follow-up runs into a single workspace so teams can get changes to merge without losing context.
- [Every fix ships with proof it works.](https://ara.so/product/qa.md): Ara turns a failing report into a reproduced bug, a regression test, and a green suite — with before/after screen recordings on the pull request. Evidence, not a claim.
- [Nothing merges until security says yes](https://ara.so/product/security.md): Ara scans every change for vulnerable dependencies and leaked secrets, drafts the fix in an isolated workspace, and holds remediation behind your approval.
- [Ara works the review thread until the diff is trusted.](https://ara.so/product/code-review.md): Ara opens a pull request, then reviews it alongside your other bots. It reads every comment, pushes fixes, and keeps going until checks are green and merge is one approval away.
- [Every run leaves the repo smarter than it found it.](https://ara.so/product/autowiki.md): AutoWiki patches the wiki, appends the changelog, and promotes durable rules after each run. The next run starts with what the last one learned.

### 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.
- [Build autonomous engineering with us.](https://ara.so/careers.md): Small team, high ownership, real verification. If that sounds right, reach out.
- [Contact Ara](https://ara.so/contact.md): Get in touch with the Ara team.
- [Start with Ara on us.](https://ara.so/pricing.md): Try the full cloud coding loop with $100 in trial credits for up to one week, then move to one shared monthly package for your workspace.
- [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.

### Blog

- [Prebaked environment snapshots, measured](https://ara.so/blog/prebaked-environment-snapshots.md): Why prebaking the environment turns a two to four minute cold start into an instant one, how the layers work, and the telemetry that proves the speedup.
- [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.

### Developers

- [Keep your agent. Hand the software work to Ara.](https://ara.so/product/api.md): Ara is a public REST API and universal remote MCP. Ask from Claude, ChatGPT, Codex, or your own service; Ara runs the work in the cloud and returns the session, evidence, and pull request to the workspace you selected.

### Platform

- [Run the whole engineering loop, not one bot](https://ara.so/product/software-factory.md): Ara turns incoming signal into a verified, reviewed pull request — then writes back what it learned, so the next run starts smarter than the last.
- [Every run gets its own machine](https://ara.so/product/computers.md): Ara provisions an isolated, ephemeral workspace per run on Mac, Linux, or Windows. It boots, does the work, opens a pull request, and tears down — every transcript and artifact kept.
- [Every run, dollar, and verdict on one screen](https://ara.so/product/analytics.md): Ara reports on itself. See runs, cost, model routing, and verification outcomes across the org, sliced by repo, team, and trigger.
- [Grade a repo before an agent touches it](https://ara.so/product/agent-readiness.md): Ara scores every repository for autonomous work, then closes the gaps. Scope permissions, seed memory, and prove the loop builds — so the first run lands a pull request, not a mess.
- [One run, the right model at every step](https://ara.so/product/model-routing.md): Ara gives every workspace a reviewed model roster for coding, reasoning, review, speed, and cost — without provider keys in the agent sandbox.

### Features

- [The repo remembers so the next run doesn't relearn.](https://ara.so/product/repo-memory.md): Durable knowledge of how the codebase boots, where the gates are, and which patterns to follow. Versioned in the repo, loaded into every run, and corrected the moment a run proves it wrong.

### 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.