autonomous · open source · zero deps

Your autonomous engineer.

An AI engineer that lives in a single Go binary. It picks up tickets, asks before changing anything, codes it, tests it, opens the PR.

Pluggable LLM, board, git host. Drive it from the CLI, web UI, or Telegram. Same memory, same brain, three surfaces.

Go to app Documentation
0
third-party deps
5
LLM providers
3
surfaces
9
indexed langs
~/projects/myapp · goon
$ goon "fix the failing auth test in user-service"
→ triage     read 4 files · 1 stale import found
→ plan       regenerate mocks · update import path · rerun tests
→ approve plan? yes
→ execute    7 lines changed across 2 files
→ test       go test ./internal/user/... PASS
→ verify     diff applied, no orphan imports
✓ PR opened: github.com/you/repo/pull/482
$ goon start
  workflow: default · polling jira every 5m
  bot:      enabled · 1 chat authorized
  web:      http://localhost:8080

[15:02:11] picked PROJ-482 · "fix flaky auth test"
[15:02:14] triage complete · awaiting confirm_repo
[15:04:33] answer: repo = harisaginting/user-service
[15:04:34] plan ready · awaiting approve_plan
[15:06:01] answer: yes
[15:06:02] executing... test... verify...
✓ [15:07:48] PR opened · notified via telegram
you   /mine
goon  Tickets assigned to you:
        PROJ-482 fix flaky auth test         · in progress
        PROJ-501 upgrade pg driver to v5      · todo
        PROJ-509 rename "tenant" → "workspace" · todo

you   /ticket PROJ-501 comment "I'll take this after 482 lands"
goon  ✓ comment posted on PROJ-501

you   /prs
goon  Open PRs in followed repos:
        #482 fix flaky auth test  (you · awaiting review)
how it works

A real engineer's loop, automated.

Goon doesn't just generate code — it follows the same loop a senior would. Read, plan, ask, execute, verify, ship. You stay in the loop at the moments that matter.

1

It picks up a ticket

Polls Jira or GitHub Issues every few minutes. Picks one ticket per tick, learns repo mappings as you confirm them — next time it auto-skips that question.

poll · triage
2

It asks before touching code

Two gates: which repo? and is this plan right? Approve, reject, or edit the plan inline. Rejected plans re-plan with your feedback (up to 3 attempts).

approval gates
3

It actually ships the work

Edits files, runs tests, verifies the diff, updates its own markdown notes about what it learned. Every shell command goes through the safety validator.

execute · test · verify
4

You get a PR

Real PR on GitHub / GitLab / Bitbucket. Review from the web UI or Telegram — approve, comment, request changes. Goon learns from the review for next time.

open PR · notify

Under the hood it's an explicit state machine — every stage is observable, hookable, and resumable.

poll board → triage → confirm repo → approve plan → execute → test → verify → update memory → open PR
safe by default

You stay in control. Always.

Autonomy without surprise. Goon pauses on the decisions that matter — and gives you everything you need to say yes.

  • Edit-the-plan approvalReject and rewrite — goon re-plans with your feedback, not just a "no."
  • Shell-command blocklistRegex validator catches rm -rf, sudo, history rewrites — hooks are checked too.
  • Strict-JSON tool contractNo prompt-injection foot-guns. Every tool call is validated against a schema before it runs.
  • Dry-run modeSet the executor to dry-run; goon plans normally but no mutation runs. Read-only tools still execute.
  • Pause / resume anywhereCLI, web, or Telegram. Daemon parks; in-flight work keeps its state.
confirm_repo · PROJ-482

Which repo should I work in?

harisaginting/user-service harisaginting/auth-lib other…
approve_plan · attempt 1

3 steps — regenerate mocks, update import path, rerun tests. OK to proceed?

yes edit plan no, re-plan
memory

A brain in two layers.

Goon isn't a stateless chatbot. It keeps two persistent stores of markdown the LLM reads and writes — so today's ticket starts smarter than yesterday's.

Knowledge

soul · always loaded

What goon should always remember. SOUL.md holds character and project facts together; HISTORY.md is the running log of past runs; topic notes are looked up on demand. Grows as it works.

./storage/memory/*.md

Skills

specialties · on-demand

Specialized playbooks: "how we deploy", "how migrations work here". Loaded only when relevant — keeps tokens lean.

./storage/skills/*.md
pluggable everything

Use what you already use.

Swap any layer with one env var. No code change, no adapter to write, no vendor lock. The same binary works on your laptop and your CI.

LLM provider
  • OpenAI
  • Anthropic
  • Gemini
  • Ollama (local)
  • mock (for CI)
Ticket board
  • Jira (Cloud + DC)
  • GitHub Issues
  • Confluence read
  • Mock (tests)
  • Linear · soon
Git host
  • GitHub
  • GitLab
  • Bitbucket
  • PR review on each
  • Auto-learned mapping
Notification
  • Telegram bot
  • Web UI dashboard
  • SSE live events
  • Custom hooks
  • Slack · soon
three surfaces

Wherever you live, goon lives there too.

CLI for quick hits at your desk. Web for review and visibility. Telegram for when you're on the train. Same memory backend, same state, no sync layer to worry about.

$ goon "summarize the .go files in cmd/"
→ read 7 files
→ cmd/root.go: subcommand dispatch
→ cmd/start.go: daemon launcher
→ cmd/memory.go: memory subcommands
✓ done

CLI

One-shot agent or background daemon. Pipeline configurable in workflow.json. Perfect for scripts and CI.

goon "<task>" goon start workflow.json
Live workflow · PROJ-482
2 pending questions · 5 tickets
approve plan?

Web UI

htmx + Tailwind dashboard. Browse files, edit plans inline, chat with the agent, manage memory layers. Live via SSE.

/app ⌘K palette file editor
👑 goon: PROJ-482 awaiting approve_plan
/answer yes
✓ resumed · executing now
/prs

Telegram

Full CLI parity in chat. /tickets, /mine, /prs, /review. Plain text talks to the model with tool use.

/auth /answer /review
why goon

Built to actually ship code.

Not a chatbot, not a copilot — an engineer that takes a ticket and brings back a PR. Seven things make it different.

Resumable state machine

The workflow is an explicit state machine. Paused gates persist to disk; restart the daemon and it picks up exactly where it left off.

Codebase indexing

Symbol index + content search across 9 languages. Built lazily on first search_code call, cached per-process. Uses ripgrep when available.

Browser tools

fetch_url + web_search let the agent read docs and error messages autonomously instead of guessing from training data.

Single binary, zero deps

Pure Go stdlib. No Python, no Node, no Docker, no Tree-sitter. Drop the binary on any machine — Linux, macOS, Windows — and run.

Auto-recovery

Rejected plans don't fail — they re-plan with your feedback. Capped at 3 attempts so it never spins forever.

Secrets stay local

Subprocess env is scrubbed of every *_TOKEN / *_API_KEY / *_SECRET before passthrough. Telegram chats can't accidentally leak credentials.

Code in the browser

The Code tab runs the same agent loop as goon "task" in a directory you pick — reads, edits, runs commands, streams each step live. Claude Code in a tab, with the safety validator on.

Let goon handle the ticket.

Open the dashboard, point it at your board, and watch it pick up its first one. Go ON — stop reading, start shipping.

Go to app Documentation