Skip to content
Driven from Telegram · Runs on your machine

Assign the ticket.
Walk away.

Five agents research, write, verify, and review the work on your own machine while you're somewhere else. Drive the whole thing from Telegram. Pay for your API key and nothing else.

Your code and your API key never leave your machine

Microsoft Store · Windows 10/11 · free for 50 queries a month · needs your own DeepSeek key. On macOS or Linux?

  • Your own DeepSeek key
  • No AutoCoder server in between
  • 50 free queries / month
Live taskconnected

Your phone · Telegram

/task add rate limiting to the /upload route

⏳ Queued on your desktop

Narration streams here. You can close Telegram.

Task complete

cost
$0.0379
api calls
19
cache hits
92%

Your machine · 5 agents

  1. Discovererrepo map · 412 files indexed
  2. Planner6-step plan · 3 files to touch
  3. Executorsurgical edits applied
  4. Verifiertypecheck + tests green
  5. Reviewer0 blocking findings

no egress · key stays local✓ ready to review

Actual per-task figures from a /total_cost report.

The shift

Pair programmers need you in the chair. This one doesn't.

Cursor and Claude Code are excellent when you're at the keyboard, reviewing as you go. AutoCoder is for the other half of the work — the tickets you'd rather hand off entirely.

  • It only moves while you watch it

    Approve a diff, approve a command, approve the next one. The agent is fast; the loop is you.

    It runs the whole task unattended

    Five agents hand off to each other — discover, plan, execute, verify, review — with no confirmation prompts to babysit.

  • Progress stops when you leave the desk

    A bug you thought of on the train waits until you're back at the keyboard to even get started.

    Start it from your phone, anywhere

    Send /task in Telegram. Your desktop picks it up, narrates progress into the chat, and hands back the finished work.

  • Nights and weekends are dead time

    The queue of small, well-specified chores never gets touched because nobody wants to spend Saturday on it.

    Queue it for 2am

    The built-in scheduler runs tasks on a cron while you sleep, then reports back with the diff and what it cost.

  • You find out what it cost in the invoice

    Subscription tiers and usage meters tell you how much is left, not what any given task actually consumed.

    Every task is itemised

    Per-task and per-agent breakdowns in the app, /total_cost in Telegram, billed by DeepSeek at DeepSeek's rates.

How it works

Four steps, then it's out of your hands

Set-up is a one-time thing. After that the loop is: send a task, do something else, read the result.

Step 1 of 4install

/start

✨ Account created — Free plan, 50 queries/month. Access key: 5X9A2C (rotates in 7 days)

What runs inside step three

Five specialised agents, each with a narrow job, handing off in sequence. Simple tasks can run on a single agent instead.

cost-routed across V4 Flash / V4 Pro
  1. Discoverer

    Reads the codebase and researches the web — live docs, CVEs, current APIs.

  2. Planner

    Turns the ticket into an ordered plan and decides which files to touch.

  3. Executor

    Makes surgical edits rather than rewriting files — fewer tokens, less to re-verify.

  4. Verifier

    Runs typechecks, tests, and Semgrep locally, then loops back on failures.

  5. Reviewer

    Line-level findings with severity, ready for CI or your own eyes.

Capabilities

Built to run without you

Everything you need to hand off a task and trust what comes back.

Drive it from Telegram

Send /task from your phone, watch live narration land in your chat, and get the finished work back the same way. Your desktop does the work — you don't have to be at it.

/task/cancel/total_cost/access_key

Delegate and walk away

Five specialised agents research, write, verify, and review in sequence — with no confirmation prompts to babysit. Drop to a single agent for simpler work.

Scheduled tasks

Queue work for tonight on a cron and let it run while you sleep. The diff and what it cost are waiting when you get back.

Runs on your machine

The agent loop, your files, and project memory stay local, and your API key never leaves the app. No tunnel, no AutoCoder server in between.

Your key, no markup

Bring your own DeepSeek key and pay the API rate directly. We never proxy your requests or resell your tokens.

Know what every task cost

Per-task and per-agent breakdowns in the app, /total_cost in Telegram. No credits, no opaque meter.

Tuned for DeepSeek V4

Routes between V4 Flash and V4 Pro per task, so cheap work stays cheap and hard work still gets the better model.

Thinking budget

Cap how many tokens DeepSeek spends on reasoning. More budget means deeper reasoning — and a bigger bill.

Local project memory

A cached repo map and findings store mean agents start each task already knowing your codebase.

Living rules & governance

Persistent project rules the agents re-read and follow on every single task.

Automated code review

Local Semgrep packs plus line-level findings with severity — JSON that CI can parse without glue code.

Notion integration

Manage pages and databases from the coding workflow. Markdown converts to Notion blocks automatically.

22 Indian languages

Write prompts with @regional and get research-backed answers back in the same language, at the English price.

Automation

The queue that runs while you sleep

Hand the scheduler a cron expression and a task. It runs unattended, returns a grouped diff, and reports what it cost.

Recurring automation

Daily, weekly, or custom cron execution with zero manual intervention.

Telegram notifications

Completion reports and cost summaries land in your chat the moment a run finishes.

Grouped, reviewable diffs

Every run comes back as a diff grouped by intent, not a wall of changed lines — read it over coffee and decide what ships.

The scheduled tasks interface: a cron expression field, agent selector, and a timeline of past runs.
Configure recurring tasks, pick which agents run, and review execution history — all inside the app.
Review

Every change gets read before you read it

Each agent works from both sides at once — live web research for CVEs and current API docs, plus deep local analysis with git-diff precision.

Context-aware

Knows the latest external knowledge — CVEs, deprecations, current APIs — and the precise local codebase state. No reviewing in a vacuum.

Privacy-preserving

Local Semgrep scanning across three rule packs (secrets, OWASP Top 10, security-audit) with zero-egress project memory.

Resilient by design

Independent circuit breakers, TTL caching, and graceful degradation keep the pipeline running when an external service is down.

Cost-efficient

Cheapest-model routing for reviews, cache-first web search, and structural digests for context. No wasted tokens.

Structured output

Per-line annotations with severity, line numbers, and concrete fixes — consumable by CI and IDEs without a parser of your own.

CI/CD ready

Reviews fire automatically after every edit and emit JSON that GitHub Actions, GitLab CI, and Jenkins read natively.

Integrations

Reaches past the repo

Two things developers ask for that most coding agents don't touch: the knowledge base your team actually writes in, and the language you actually think in.

Native Notion integration

Connect a Notion token in Settings → Integrations, then manage pages, databases, and content in plain language without leaving the coding workflow.

  • Search, create, edit, and organise from a prompt
  • Markdown converts to Notion blocks automatically
  • Headings, lists, code blocks, tables, quotes, dividers

Prompt in 22 Indian languages

Prefix any prompt with @regional and get research-backed answers back in the same language — follow-ups included.

No premium tier, no surcharge — regional prompts cost exactly what English prompts cost.

By the numbers

What it actually costs, and what it actually catches

Our own figures come straight out of the app. The research below is about AI code review generally — it's the reason the category works, not a claim about our results.

$0.038

a typical task

19 API calls, DeepSeek V4 Flash

95%

prompt cache hit rate

across 28 tasks — $3.98 saved

5

agents per task

or one, for simpler work

50

free queries / month

no card, no trial clock

Task cost varies with task size and model. V4 Pro runs roughly 3× V4 Flash.

Independent research on AI code review

89%

of known vulnerability signatures caught by AI code review

GitHub Copilot Code Review — Autonomi AI, Jun 2026

31.8%

reduction in PR review cycle time across 300 engineers

DeputyDev enterprise study — arXiv:2509.19708

3,000+

AI code reviews processed every week at Faire

DX Newsletter — Aug 2025
Remote control

Everything you need, from a chat window

Account setup, key rotation, billing, and live task submission all happen in Telegram. There is no web dashboard to log into.

2 · Get your key

Run /start to register and receive a 6-digit access token.

3 · Log in

Enter the key in the desktop app and start assigning work immediately.

Command reference

/start

Onboarding

Registers your account, issues the first 6-digit access key, grants 50 free queries a month.

/access_key

Key rotation

Issues a fresh 6-digit key on demand. Rotates automatically every 7 days regardless.

/task

Remote submission

Sends a coding task to your desktop from anywhere. Queued, executed, narrated back live.

/cancel

Cancellation

Stops the running task, or drops the next queued one if nothing is running.

/total_cost

Usage diagnostics

Lifetime USD spend, input/output/cache-hit tokens, cache savings, and tasks completed.

/buy_package

Upgrade

Opens Stripe checkout for 30 days of premium access.

AutoCoder Official Botonline
/start
11:30

Account created

Free plan · 50 monthly queries

5X9A2C

Key rotates every 7 days.

11:30
/task add rate limiting to the /upload route
11:31

Queued on your desktop

Narration streams here as it runs — no need to stay connected. Use /cancel to stop it.

11:31
/total_cost
12:43

Lifetime usage

total cost
$1.7608
tasks completed
28
cache hits
95% of input
saved by cache
$3.9762
12:43
Message @AutoCoderOfficialBot…
Comparison

Where it's different — and where it isn't

The last two rows are the honest answer if what you want is a coding agent in your editor with the strongest model behind it.

CapabilityAutoCoderCursorGitHub CopilotClaude Code
Control from a chat appTelegram — submit, steer, receiveOnly
Scheduled / unattended runsBuilt-in schedulerBuilt-inVia ActionsVia external cron
Runs without confirmationsDefault behaviourHands-freePartialBasicConfigurable
Who your code is sent toYour model provider only, via your keyCursor servers, plus the providerGitHub / MicrosoftAnthropic only
Bring your own API keyRequired — you pay list priceNo markupOptionalNoOptional (API mode)
Multi-agent orchestration5 agents, or single-agent modeSingle agentSingle agentSub-agent delegation
Regional language support22 Indian languages, no surchargeOnly
Model capability ceilingDeepSeek V4 Flash / ProFrontier modelsFrontier modelsClaude Opus / SonnetStronger
Editor integrationStandalone desktop appFull IDEDeepestDeep IDE integrationCLI + IDE extensions

To be precise about privacy: the agent loop, your files, and your project memory stay on your machine, and your API key never leaves it. Code an agent puts in a prompt still goes to DeepSeek, under your own key — there is no AutoCoder server in between, and we never see either one.

So which one should you reach for?

These are different tools for different moments, not rivals. Most developers who use AutoCoder keep a pair programmer open too.

Reach for Cursor / Claude Code

  • You want to review every edit as it lands
  • The task needs the strongest available reasoning model
  • You live in the editor and want the agent there too
  • You're exploring an unfamiliar architecture and want to steer

Reach for AutoCoder

  • The ticket is well-specified and you'd rather not watch it
  • You're away from the desk and want work moving anyway
  • It should run overnight, on a schedule, unattended
  • Your code and your API key must stay on your own machine
Pricing

A subscription plus your own token spend

Both halves, always stated together — the subscription alone isn't what running AutoCoder costs.

MonthlyYearlySave 17%

Free

Enough to find out whether the workflow suits you.

₹0/month

+ your DeepSeek token spend

  • 50 queries per month
  • Bring your own DeepSeek key
  • Runs locally on your machine
  • Access to 2 specialised agents
  • Community support
  • Unlimited queries
  • All 5 agents in parallel
Start free on Telegram

Send /start — no card required

Most popular

Premium

Full autonomy — all five agents, no query ceiling.

899/30 days

≈ $11 · + your DeepSeek token spend

  • Unlimited queries
  • Bring your own DeepSeek key
  • Runs locally on your machine
  • All 5 agents in parallel, or single-agent mode
  • Scheduled and recurring tasks
  • Premium Telegram community
  • Priority support
Go Premium

/buy_package — Stripe checkout

The other half: what DeepSeek charges you

Tokens are billed by DeepSeek, on your key, at their published rates — we never proxy your requests or add a markup. AutoCoder caches aggressively, so most input tokens bill at the cache-hit rate.

ModelInput / 1MOutput / 1MCached input
V4 Flash$0.14$0.28$0.0028
V4 Pro$0.435$0.87$0.003625

Rates as published by DeepSeek, August 2026. A typical task on V4 Flash lands in the low single-digit cents; V4 Pro costs roughly 3× that.

Both plans need the desktop app — download for Windows.

On macOS or Linux? Not yet.

The desktop app is Windows-only today, and we would rather say that plainly than let you find out at the Store page. Two things you can do instead.

Talk to the bot from anywhere

The Telegram side needs no install and works on every platform. You still need a Windows machine somewhere to run tasks against — but if you want to see how the workflow feels first, start here.

Open the bot

Get told when there's a build

No date to promise. One email when it exists, and nothing else — the list is also how we decide which platform to do first.

Which platform?
FAQ

Questions worth asking first

  • The agent loop, your files, and your project memory stay on your machine, and your API key never leaves the app. What an agent puts in a prompt does go to DeepSeek, under your own key — that's how any hosted model works. The difference is that there is no AutoCoder server in between, so we never see your code or your key.

  • Two things, and you should count both: the subscription (₹0 on the free tier for 50 queries, ₹899/month for unlimited) plus your own DeepSeek token spend, billed directly by DeepSeek at their rates. A typical task on V4 Flash lands in the low single-digit cents. Run /total_cost in Telegram at any time for the running total.

  • Yes — and awake. AutoCoder runs the orchestrator in-process on your desktop; Telegram is the remote control, not the runtime. Tasks you send from your phone queue on that machine and execute there, so if it sleeps or you shut the lid, the run pauses until it wakes. Before scheduling anything overnight, set the machine not to sleep. That's the honest trade for keeping your code and your key local — there is no cloud runtime to fall back on.

  • Windows desktop today, via the Microsoft Store. It's a young project — if you're on macOS or Linux, the honest answer is “not yet.”

  • Yes — it's required, not optional. You paste it into the app once and pay DeepSeek list price directly. We don't resell tokens, bundle credits, or take a cut, which is why there's no markup to explain.

  • Two of the five agents exist for exactly that: the Verifier runs typechecks, tests, and local Semgrep packs and loops back on failures, and the Reviewer produces line-level findings with severity levels. You still get a grouped diff to read before anything ships. And /cancel stops a running task from your phone.

  • Persistent project rules live alongside the repo and are re-read on every task, so conventions stick without repeating them in each prompt. You also control the thinking budget — how many tokens the model may spend reasoning — and whether a task runs on all five agents or just one.

  • The reviewer emits structured JSON with per-line annotations, severities, and fix suggestions, which GitHub Actions, GitLab CI, and Jenkins parse natively. Scheduled tasks return the same grouped diff a chat-box run does, so you review it before anything ships.

  • Often you should. They're pair programmers — excellent when you're at the keyboard, reviewing as you go, with stronger models behind them. AutoCoder is for the other case: work you want to hand off entirely. If you want to be in the loop on every edit, use theirs. If you want the work done while you're doing something else, use ours.

  • It rotates every 7 days automatically, and you can force a new one at any time with /access_key. It authenticates your desktop app to your own Telegram account — it is not your DeepSeek key, which never leaves your machine.

  • Yes — prefix a prompt with @regional and you'll get research-backed answers in 22 Indian languages, at the same price as English. No surcharge, no separate tier.

Something not covered? Ask the bot directly or email support@autocoder.dev.

Give it a ticket tonight. Read the diff over coffee.

Fifty queries a month are free, your key stays on your machine, and the whole thing takes about five minutes to set up.

  1. 01Download the app
  2. 02Send /start to the bot
  3. 03Assign your first ticket