sinatra is an autonomous coding agent that lives in your GitHub and Linear. Assign it an issue. It opens a branch, writes the code, runs the tests, and ships a clean PR while you're in your standup.
Toggle the phase settings in the dashboard, or commit a .sinatrarc to your repo for the full set. Set the test command, pick the model and engine, tune reasoning effort, and switch the planning and brainstorm phases on or off.
Repo settings
How sinatra works in this repo
Run your test command before each PR
Plan complex tickets before coding
Brainstorm vague tickets first
Resolve conflicts with main before each run
iSettings live in .sinatrarc, committed to your repo.
Code review
Reviews itself. Replies to yours.
PRs open as drafts. Sinatra reviews its own diff against the ticket, fixes its own mistakes, and only then marks the PR ready, so nobody gets pinged for half-done work. Request changes and it reworks, replies in-thread, and ships the follow-up commit.
● PR #41272 review comments resolved
RM
Riya · 4 min ago
Can you make sure the focus trap respects nested portals?
@sinatra · just now
Good catch. Threaded the FocusManager through portal boundaries and added a nested-portal story. Pushed to sin/eng-2104. Re-requesting review.
Integrations
Plays well with your stack.
sinatra slots into the tools you already use. No new dashboard to babysit, no new login for your team. Just assign, review, and merge.
GH
GitHub
● Available now
Add the Sinatra label to an issue to hand it over. Reads your PRs, checks, comments, and review threads; writes branches, PRs, and in-thread replies. Zero config.
L
Linear
● Available now
Assign tickets to Sinatra. Updates the ticket as work progresses, posts the PR link when it's ready.
S
Slack
● Coming soon
Get pinged in Slack when Sinatra opens a PR or needs your eyes. Reply right in the thread.
J
Jira
● Coming soon
Assign Jira tickets to Sinatra. It updates the ticket as work progresses and links the PR when it's ready.
Comparison
Why teams pick Sinatra.
GitHub-native, model-agnostic, and we don't mark up your LLM bill. The incumbents don't ship like that.
Feature
Sinatra
Devin
OpenHands
Factory
Native GitHub-issue trigger5
✓
✕
✓
~
Native Linear-ticket assignee
✓
✓
✕
✓
BYOK / model-agnostic1
✓
✕
✓
~
No LLM markup2
✓
✕
✓
✕
Fully-managed tier (infra + LLM)
✓
✓
✓
✓
Transparent pricing3
✓
✕
✕
✕
Replies in-thread on PR review4
✓
~
~
~
1Factory supports BYOK in their CLI only, not their web/mobile droids.
2Sinatra passes LLM token costs through at provider rates with zero markup. Devin and Factory bundle LLM into seat or credit pricing; OpenHands also offers at-cost usage.
3Every Sinatra tier publishes a price. Devin, OpenHands, and Factory all gate their enterprise tiers behind "contact sales".
4Submit a review that requests changes and Sinatra reworks and pushes the follow-up commit autonomously, with no re-trigger or mention needed. OpenHands and Factory require an @openhands / @droid mention to act on PR feedback. Devin auto-responds to PR comments only while its session is unarchived.
5Label a GitHub issue and Sinatra runs the whole loop on it. The label ships with the GitHub App install. OpenHands Cloud offers a comparable label/mention trigger. Factory requires installing their droid-action workflow and an API key per repo; Devin doesn't document a GitHub-issue trigger.
Memberunique person who starts a task, via Linear assign/@-mention or the GitHub labelWorkspaceone GitHub org or personal GitHub account, each billed separatelyMinimum 1 seat per workspace
FAQ
Common questions.
Can't find an answer? Email the team and we reply quickly.
Yes, and there's no card required to start. On the free tier you get 5 tasks a day when you bring your own model key (or connect a Codex / ChatGPT subscription), or 1 task a day on our keys. That's enough to watch Sinatra take a real issue from assignment to an open PR on your own codebase. When you're ready for a team, the Monthly plan is a flat $20 per member per month: hosted sandboxes and orchestration, with no markup on your LLM bill (you pay model cost at provider rates, or keep using your own key). Enterprise adds a custom annual contract. You can move from free to paid whenever it makes sense, and nothing about the workflow changes.
If you haven't connected anything, Sinatra runs on our keys and passes the model cost through at cost, with no markup. Connect an Anthropic or OpenRouter API key, or a Codex / ChatGPT or Claude subscription, and it uses yours instead. With nothing pinned it picks based on what you have connected, then posts the engine, model and credential it chose straight into the ticket, so a run is never a black box. Pin a specific model per repository in .sinatrarc when you want predictability, and pin a separate one for the planning and brainstorm phases if you'd rather those ran on something cheaper. Pin a model you have no credential for and the run stops at startup naming the missing credential, before it spends anything. Free-tier tasks that run on our keys use a single fixed model.
No. Sinatra only ever works in branches and opens pull requests. It never merges, deploys, or runs anything against your production environment. Merging stays with you and your CI, exactly like a human teammate, so your usual branch protection and required reviews still gate everything. Each task runs in its own isolated, short-lived sandbox: Sinatra checks out your repository, does the work there, and shuts the sandbox down when the task is done; idle sandboxes are archived automatically within a day. Any credentials or model keys you connect are stored encrypted and used only to run the task you assigned. And we don't use your code or content to train our own models, and we don't sell it.
In an isolated sandbox that only your workspace can use. Sinatra checks out your repository there, does the work, and stops the sandbox when the task ends; a sandbox left idle stops after two hours and is archived after a day. Sandboxes are never shared between workspaces: reusing one requires either a matching workspace label or a workspace-scoped name, and anything that can't be proven yours is treated as not found. We never copy your checkout into our database. We do keep repository metadata, the branch and pull request we opened, the commit we started from, per-run token and cost totals, and the raw webhook payloads GitHub and Linear send us, which carry issue and comment text and, on a review comment, the diff hunk it was left on. The sandbox can't reach the open internet either, only a default-deny allowlist covering GitHub, Linear, your model provider and the usual package registries.
It does its best work on big codebases. Each task runs in its own sandbox with the full repo checked out, so the agent reads and searches across the whole codebase before it touches anything. For very large repos, .sinatrarc can switch the checkout to a blobless clone so the initial clone stays fast.
It's built to. The agent is told to add or update tests for behavior changes, and to read your existing tests first so the new ones match your conventions rather than inventing a second style. Every run finishes with a written record of what it actually verified and what risk it knowingly left behind. Point .sinatrarc at your test command and Sinatra runs it in the sandbox once the agent is done, re-running the agent to fix failures up to twice. Tests that still fail don't block anything: the pull request stays open with the failure reported on the ticket, because a red test you can see beats a run that quietly gave up. Sinatra also reviews its own diff before marking the PR ready, and thin assertions and uncovered branches are among the things it looks for.
Ship the backlog. Get your Saturday back.
Your AI engineer in GitHub and Linear. Start free, set it up in minutes.