What do you want
to build?
Pick a repo and describe the change in your own words. CodeBeast writes a PRD and an implementation plan, builds each step on its own branch on a cloud sandbox — independent steps in parallel — and integrates them into a single pull request. Then it reviews the diff and tests the app in a real browser, posting pass/fail results and screenshots right on the PR.
Creating tasks is free — credits are only spent while a sandbox box is running.
The loop every task moves through
The screens you'll live in.
A board your tasks move across, a task thread where every stage is visible — PRD, plan, build, review, test — a chat you can start anything from, and a report that lands directly on your pull request.
Add CSV export to the orders page.
Add rate limiting to the public API.
Migrate checkout to the new payments SDK.
Fix the failing signup validation test.
Add a login screen with GitHub OAuth.
Upgrade the app to React 19.
Task board — new tasks land in ToDo for free; hit Start building and the task moves to In Progress as a sandbox box boots. Stop a box, answer questions, or open the PR from the card.
Add a login screen with GitHub OAuth.
Task detail — the whole pipeline in one thread: PRD, implementation plan, build (each step on its own branch, independent steps in parallel), the integrator merging them into one PR, then the review pass and the browser test run. Add a note or stop the box anytime.
what is the current background color?
#242424 set on :root — see src/index.css:7–10. Light mode override: #ffffff via @media (prefers-color-scheme: light).please change it to #232323 for default dark mode and #fefefe for light mode
Set the app's background color to #232323 for default dark mode and #fefefe for light mode.
Chat — ask questions about your repo and get answers grounded in the code. Describe a change instead and it becomes a task: hit Start building and it runs unattended — chat-created tasks auto-approve the PRD and plan for now.
New task — plain English in, repo and branch picked, harness chosen. "Create only" parks it in ToDo for free; "Create and start" boots a box immediately. Tasks created here pause for clarifying questions and your PRD approval before any code is written.
feat/login/integratedReview & Test — after the PR is raised, a review agent reads the diff, then a test agent runs the repo on the sandbox machine, walks the plan's checks in a real browser, and pushes pass/fail results with screenshots — plus the review notes — as a comment on the PR.
Four stages. One pull request.
CodeBeast doesn't guess and dump a diff on you. It writes the spec and the plan first, builds each step on its own branch, and brings the evidence — review notes, test results, screenshots — back to the pull request.
Create & start
Describe the task from the board or in chat — it lands in ToDo for free. Hit Start building and a dedicated sandbox box boots for it, moving the task to In Progress.
→PRD & plan
It drafts a PRD, then an implementation plan that breaks the work into steps with branches. Board-created tasks pause for your clarifications and approval; chat-created tasks auto-approve and run unattended.
→Build & integrate
Each step builds on its own sub-branch — independent steps in parallel, dependent ones in order. An integrator then merges the branches in dependency order and raises a single pull request on your repo.
→Review & Test
A review agent reads the diff, then a test agent runs the repo in the sandbox, walks the plan's checks in a real browser, and posts pass/fail results with screenshots as a PR comment. You merge and mark the task done.
The findings live where you already review code.
No separate dashboard to check, no report to chase. Everything CodeBeast learned about its own change is posted to the pull request as a comment — so reviewing agent work feels exactly like reviewing a teammate's.
- A PRD and a plan first. The spec and the step-by-step plan are written before a line of code — so the diff has a contract to be judged against.
- One real pull request. Steps build on their own branches — independent ones in parallel — and an integrator merges them in dependency order into a single PR. Branch protections still apply.
- A review pass on its own work. After the PR is raised, a review agent re-reads the change looking for what's wrong with it.
- Browser test results, with screenshots. A test agent runs the repo in the sandbox, walks the plan's checks, and attaches pass/fail results and screenshots to the PR comment.
What to hand it — and what to keep.
Agent tools tend to promise everything and then disappoint on the specifics. Here is the honest version. Teams who start on the left column build trust fast; teams who start on the right conclude the whole category is hype.
Hand it these
Well-specified work with a clear finish line.
- Bugs with a reproduction. A stack trace or a failing case pasted into the task description is usually enough to go from task to merged fix.
- Failing and flaky tests. "Fix a failing test" is a one-line task — the clarify step surfaces whether you want the symptom or the root cause fixed.
- Upgrades and dependency work. Framework bumps, deprecation sweeps and security patches, each raised as its own reviewable PR.
- Well-scoped features. A login screen, an export button, a new endpoint — anything a PRD can pin down in a page.
- Questions about the codebase. "What does this repo do?" and "Where is auth handled?" are chat messages, not tasks — and cost nothing to ask.
Keep these
Work where the hard part isn't the code.
- Greenfield architecture. Choosing the shape of a new system is a judgement call with years of consequences. Have the argument yourselves.
- Ambiguous product work. If two engineers would build it differently and both be right, the clarify step will tell you — the task isn't ready yet.
- Performance work needing real traffic. It can profile and propose, but load-shaped intuition on production data is still yours.
- Live incidents. Use it for the follow-up fix and the regression test, not for the thing at 3am with the pager going off.
Built like a teammate, not a chat box.
Everything in CodeBeast exists to move a task from a sentence to a merged pull request — visibly, and on infrastructure you control the cost of.
A sandbox box per task
Every task runs on its own dedicated cloud machine. Pick the size — t3.micro to t3.xlarge — bigger boxes build and test faster, and you can stop a box from the board at any time.
PRD and plan before code
Every task starts with a PRD, then an implementation plan that breaks the work into steps. Board-created tasks pause for your clarifications and approval; chat-created ones auto-approve and run unattended.
Chat with your repo
Ask what the repo does, where auth is handled, or what the current background color is. Describe a change instead, and the chat turns it into a task — one Start building click and it's on the board, running.
A board, not a black box
Tasks move ToDo → In Progress → Needs Input → In Review → Completed. You always know what's running, what's waiting on you, and what's ready to merge.
Parallel branches, one PR
The plan's steps build on their own sub-branches — independent steps in parallel, dependent ones in order — and an integrator merges them in dependency order into a single PR. Branch protections, required reviewers and CI gates all still apply.
Review & Test, built in
After the PR is raised, a review agent reads the diff, then a test agent runs the repo in the sandbox and walks the plan's checks in a real browser — posting pass/fail results, screenshots and the review notes as a PR comment.
Credit-based compute
Billing follows the machine, not the seat. Boxes are metered per hour in credits, tasks in ToDo cost nothing, and stopping a box stops the spend.
Your choice of harness
Pick the harness per task or per chat. The default works out of the box; switch when a job calls for a different engine.
Works with your GitHub repos
Sign in, connect your repositories, and pick the repo and branch per task. PRs, comments and merges happen where your code already lives.
Pay for compute, not seats.
Billing is based on machine compute, measured in credits. Each task runs on its own sandbox box, metered per hour by size — you choose the machine your boxes launch on.
Bigger machines build and test faster — and spend credits faster. A size change applies to boxes started after it; running boxes keep their size.
How the meter works
- Creating tasks is free. Write as many as you like — a task in ToDo uses no compute and costs no credits.
- Credits burn only while a box runs. The meter starts when a sandbox box boots for your task and stops when the box does.
- Stop a box anytime. Every In Progress card has a Stop box button — hit it and the spend ends immediately.
- Size to the job. Run quick fixes on a t3.micro at 10.4 credits/hr; move to a bigger box when a build needs the horsepower.
- Chat questions don't boot boxes. Asking about your repo in chat doesn't spin up a machine.
Built by the team at DronaHQ
CodeBeast is built by DronaHQ, the team behind the low-code platform used by engineering and product teams to ship internal tools at scale.
Before you connect a repo.
See a task become a PR, live.
Thirty minutes, your questions, a real run. Tell us what you'd hand it first and we'll walk the whole loop — task, PRD, plan, parallel branch build, integration, and the review & test findings landing on the pull request with screenshots.
- A live task on a real repository — not a canned recording.
- Straight answers on credits, machine sizes and what a task really costs.
- An honest read on which of your workloads fit — and which don't.
Describe your first task today.
Sign in, connect a repository, and type what you want built or fixed. CodeBeast will write the PRD and the plan, build it across branches, and come back with a single pull request — review notes, test results and screenshots attached.
Creating tasks is free — compute is billed in credits only while a box runs. See how we handle your data in our privacy policy.