Areli's agents read your conventions, remember your codebase, and ship reviewable pull requests while you do real work. One ticket in, one PR out — every time smarter than the last.
The setup is deliberately small. Areli is opinionated about agent conventions but agnostic about your stack — JIRA, GitHub Issues, Linear, or GitLab Issues, plus a GitHub repo, and the rest is your team's existing process, augmented.
Paste an API token for each. We encrypt at rest with envelope-scoped keys, and verify scope on the way in.
Your AGENT.md, lint config, Prettier rules, and any custom skills — drop them in. Every run reads them first.
Backend, frontend, infra, or fullstack. The orchestrator routes each ticket to the right specialist based on labels.
Every PR opens as a draft. Areli never merges, never approves itself, never bypasses required checks. You hold the merge button; Areli holds the keyboard. Comment to request changes — a follow-up run lands on the same branch within minutes.
The backlog you already have — labels, components, workflow, states — is the interface. Areli reads it on the way in and writes status transitions on the way out. Nothing else changes.
Areli's orchestrator reads your existing labels and components to pick the right specialist team. No new label scheme to learn. If a ticket has a `backend` label, the backend specialist takes it.
We map by destination status name, not ID — your custom workflow (`In Progress`, `Started`, `Doing`) all work. Areli writes status transitions on the existing workflow path; we don't replace it.
Read-only access to every field Areli doesn't write. Your sprint, your epic link, your story points — preserved verbatim. We touch one column: `Status`. Everything else is yours.
The orchestrator reads each ticket and routes it to the right specialist. An architecture pass shapes the structural side before code is written, and QA reviews the diff before the PR opens. You can override per project.
End-to-end features across stack boundaries
No agentic tool ships clean every time. The honest question is what the system does when it doesn't. Here are the three cases that matter, each backed by real infra in the dashboard timeline.
The run aborts before any push. The credit hold is released, not charged. The timeline shows you exactly which test broke and the last shell command the agent ran — same telemetry the dashboard uses for a successful run, just with the diff still in the sandbox.
A reviewer comment fires a webhook. The agent reads every reviewer comment on the PR, decides per-comment whether it agrees, and either pushes a fix to the same branch (PR auto-updates, no new PR) or posts a polite technical reply explaining its reasoning. No new credit per follow-up.
The decision is recorded as a tombstoned memory. Future runs on this project will see the rejection signal and avoid the same approach — the agent learns from the close, not just the merge. Memories carry source_run_id and source_pr_url for provenance.
↳ Every state transition + tool call is in the run timeline · queryable, exportable
Every run extracts durable lessons — conventions, codebase facts, decisions, recoveries. They're retrieved on the next run via a hybrid of vector + trigram search, with recency decay and a pinned-curation override.
First ticket. Areli only knows what your AGENT.md tells it.
Two months in. The memory store knows your repo's grain.
↳ Memories are per-project, encrypted, and exportable
The hidden cost of agentic PRs is normally the back-and-forth on review. Reviewer comments fire a webhook; Areli responds on the same branch within minutes — no new PR, no re-context, reviewer never leaves flow.
Areli ships the diff + a written rationale. Marked draft until you mark ready.
Inline or top-level. Areli reads every reviewer comment on the PR.
Per-comment decision. Valid → commit lands on the same branch. Pushback → polite reasoned reply.
Same PR, no re-routing, no re-context. Required checks re-run on the new commit automatically.
You hold the button. The PR carries lineage back through every Areli pass + every human review.
↳ Reviewer follow-up runs are included on Team and Enterprise plans
Slide the three inputs. We snap the cost to a real plan + top-up mix so you can show your CFO a concrete monthly delta.
Credits are pre-purchased — runs never overdraft. Top-ups never expire. Plans cancel from a Stripe-managed billing portal; we never hold you hostage on the way out.
Enough to ship a few real pull requests and decide.
20 PRs a month for less than two hours of contractor time. For the developer shipping every week.
90 PRs a month for the price of one engineer-day. Three seats, shared memory, priority queue.
Every project connects to your Anthropic account, so model spend is billed by Anthropic — not us. Areli only meters its own runtime (Modal sandbox, Postgres, git ops), which means each run costs 1 credit instead of ~3. Same $59 Pro plan → ~20 shipped PRs a month instead of ~7.