Contributors
For contributors
Work across projects without carrying each one’s unwritten rules in your head.
Early and moving fast·Apache-2.0
Run all your coding agents together on real repositories.
One desktop app. Your agents, your machine, your call on anything that ships.
Bring your own agent·Nothing leaves your machine
osade — ledger
sorted needs-you first⚑gateopen PRauth-refresh
⚑inputneeds youcsv-import
●liveimplementingrate-limit
✗failverifyparser-fix
○idlequeueddocs-typo
merged
✓mergedpr #4421null-guard
A ledger, not a kanban board. With eight agents running, the question you’re actually asking is “who needs me?”
01 // Isolation
Git worktrees
One tree per agent, never shared
02 // Evidence
Mined conventions
Every rule cites a real PR
03 // Control
Human gates
Nothing public without you
The premise
The problem is review, not code.
Open source is closing the door on autonomous AI contributions. The bottleneck is review capacity, not code production.
So a tool that helps you open more agent PRs makes the problem worse. Osade is built for the opposite goal.
Reduce the review cost of a contribution until an agent-assisted PR is cheaper to review than a human one.
That sentence is why verification, evidence-cited conventions and human gates are core here rather than settings you can turn on later.
Godot
Banned autonomous agent use outright.
curl
Shut down its bug bounty over AI submissions.
Maintainers
Report roughly 1 in 10 AI PRs meets their bar.
The number being moved
Review rounds to merge
It’s instrumented. If the conventions miner doesn’t move it, that gets reported rather than buried.
Bring your own agent
It doesn’t ship a model.
Osade is not another AI. It’s the environment around the agents you already pay for — it drives the agent CLIs on your PATH. Switch agents without changing your workflow.
Claude Codeclaude
Codexcodex
Geminigemini
Cursorcursor
Copilotcopilot
OpenCodeopencode
Pipi
Droiddroid
Ampamp
Clinecline
Grokgrok
Claude Codeclaude
Codexcodex
Geminigemini
Cursorcursor
Copilotcopilot
OpenCodeopencode
Pipi
Droiddroid
Ampamp
Clinecline
Grokgrok
Devindevin
Kirokiro
Kimikimi
Kilokilo
Qwenqwen
Hermeshermes
Agyagy
OMPomp
Mastra Codemastracode
Qoder CLIqodercli
Makimaki
Devindevin
Kirokiro
Kimikimi
Kilokilo
Qwenqwen
Hermeshermes
Agyagy
OMPomp
Mastra Codemastracode
Qoder CLIqodercli
Makimaki
Osade branches on capabilities, never on identity.
Each agent declares what it can prove it supports, and Osade adapts instead of flattening everything to a lowest common denominator. An agent without hook reporting still works — it relies on screen detection for its lifecycle. Adding a new agent is a catalog entry plus a detection manifest, not an orchestration change.
plan-moderesumehook-reportingheadless-run
Your agents
Whichever ones you have installed, running as themselves on your machine.
Osade in between
Worktrees, verification, mined conventions, memory — then a gate.
GitHub
Reached only through an action you approved, one at a time.
How it works
An environment, not an assistant.
AI coding agents are good at writing code. Contributing to a real open-source project is more than writing code — you need the repository’s conventions, its real checks, and to know when not to open a PR.
Start
Start by typing, not by configuring.
A new chat is an empty box. Type, and an agent starts working in a terminal you don’t have to look at. Branch names and titles come from what you wrote. No task form, no YAML, no pre-flight configuration to get one agent moving.
no setup
you
fix the token refresh race in the auth client
↓
osade
- branch:
- agent/auth-refresh-race
- agent:
- claude
- lane:
- implementing
no task form · no YAML · no pre-flight configuration
Fan-out
Several agents. One conversation.
Put @claude and @codex on separate lines and the message fans out to both. Each gets its own branch and its own worktree, and they share one transcript — plus a short digest of what the others have done, so they’re not working blind next to each other.
shared transcript
@claudetake the parser
@codexwrite the regression test
Claude
agent/parser-fix
own worktree · own branch
Codex
agent/parser-test
own worktree · own branch
└──── one conversation, and each agent gets a digest of the others ────┘
Isolation
Your real checkout stays your real checkout.
Most agent tools drop you into a branch you didn’t ask for. The first chat in a repo attaches to your working tree, on whatever branch is already checked out — branch out when you’re ready, and uncommitted changes come with you. Extra chats and extra agents get isolated worktrees automatically.
never the same tree twice
TreeAgentLaneAction
main
you
your checkout
take over
agent/parser-fix
Claude
implementing
selected
agent/parser-test
Codex
verifying
take over
agent/csv-import
OpenCode
queued
take over
$ Claude Code editing src/parser.rs · isolated worktree
Conventions
Every repository has a way of working.
Agents know how to code. They don’t know how your project works. What gets a PR merged is conformance to a project’s tacit rules — and those rules are already in the record: in review comments, in what got rejected, in the diff between what was submitted and what was merged. Osade mines that record.
mined, then tested
A rule without evidence is not a rule — uncitable candidates are rejected at write time.
capped at 40 rules · ~2000 tokens
One concern per PR, no drive-by refactors
evidence: PR #1234 (closed unmerged) · PR #1290 (changes requested)
Integration tests required for anything touching the client
evidence: .github/workflows/pr.yml
Discuss API changes on the issue before implementing
evidence: PR #1187 (changes requested) · PR #1402 (closed unmerged)
Candidates are tested against merged PRs the miner hasn’t seen. If merged PRs routinely violate a rule, it’s marked rejected rather than shipped.
Verification
Verification before it costs a maintainer anything.
Osade derives a verification plan from evidence — your PR-triggered CI workflows first, then package manifests, then what CONTRIBUTING says. It shows you the plan and lets you edit it. An inferred command never runs silently the first time, and a CI step it can’t resolve is reported as skipped rather than invented.
derived from evidence · editable
pnpm lint
.github/workflows/pr.yml
pnpm test --filter client
.github/workflows/pr.yml
cargo fmt --check
package manifest
deploy-preview
unresolved CI step
the loop
fail → failing command + log tail goes back to the agent ↺
pass → reviewable, and only now can a pull request be opened
Gates
Nothing leaves your machine without you.
Commits are local and reversible. Everything that becomes public is gated. A gate card shows the exact action, the rendered diff or the literal comment text, which task it came from, and the verification state. Approve, deny, or edit and approve.
public writes wait on you
read / edit / testauto
commitauto, reversible
pushyou
open pull requestyou, after verification
PR / issue commentyou
submit reviewyou
force-pushyou, never overridable
create forkyou, never overridable
add dependencyyou
mergenever, by Osade
The payload is hashed when the gate is requested and re-hashed when it executes. If the text changed in between, it aborts — an “approve this comment” decision can’t be executed against different words.
Memory
Shared memory that can’t poison itself.
Agents share what they learn across five scopes. But one agent’s wrong guess becoming every future agent’s ground truth is the easiest way to get this feature actively wrong — so nothing is promoted above task scope without verification, and conventions never transfer across repositories.
verified writes only
Claude Code
Discovers a constraint while implementing.
task scope
the write gate
A verification run confirmed it. Only now does it reach repo scope.
promoted
Codex
Starts with it. No rediscovery, and nothing unverified.
repo scope
Scopes:
personal·org·repo·task·agent
Conventions never cross repositories. What travels is ecosystem know-how, tagged as such — “under pnpm workspaces, run tests with
--filter” is portable; “this project wants RFCs first” is not.Triage
The best thing an agent can do is often not open a PR.
A maintainer will accept a bot that saves them 40 minutes of triage long before they accept a bot that adds to their review queue. So Osade has a task type that terminates in an artifact instead of a pull request.
No PR. Just the answer, with the evidence attached.
terminates in an artifact
reproduceDoes the reported bug actually reproduce, in a clean worktree?
bisectWhich commit introduced the regression?
failing-testA test that demonstrates the bug.
duplicate-checkDoes this issue already exist?
verify-pr-claimDoes a human’s PR do what its description says?
Contribution lifecycle
From issue to contribution.
The same seven steps every time, in the open, with the evidence for each one kept next to the work rather than in a settings screen.
01
Understand
Import the issue, or just describe the work
02
Isolate
Its own worktree, its own branch
03
Execute
The agent you chose, under this repo’s mined rules
04
Verify
This repo’s real checks, failures fed back
05
Review
Diff, checks and evidence in one window
06
Ship
Behind a gate you approve
07
Remember
Verified knowledge promoted, the rest discarded
Observability
Watch it, or don’t.
Files, Checks, Diff and Rules sit next to the chat. The composer stays live on all of them and attaches whatever you’re looking at — so “why did you change this” works while you’re reading the hunk.
Watching an agent live opens a real terminal attached to the same session. No replay, no mirror, no black box.
chat + four lanes
agentfileschecksdiffrules
$ claude — attached to the running session
edited src/auth/refresh.ts · 2 files staged
verification lane: pnpm test --filter client
● live · implementing · agent/auth-refresh-race
why did you change this? — attaches the hunk you’re reading
Who it’s for
Built for the people doing the reviewing.
Maintainers
For maintainers
Get contributions that follow your project’s practices, with the evidence for why they were followed.
Agent developers
For agent developers
A persistent environment with real worktrees, real verification and real gates to operate in.
Architecture
Your agents outlive the window.
Three processes. Two of them keep running after you close the app. Come back and the worktrees, sessions, task state and transcripts are where you left them.
Osade doesn’t reimplement terminals — a headless Rust substrate owns PTYs, VT parsing, git worktrees and agent process detection.
close the window · agents keep working
Electron app
Chats, lanes, files, diffs, checks, gates
tRPC + WebSocket · 127.0.0.1 only
Osade daemon
Lifecycle, verification, gates, GitHub, conventions, memory
SQLite + change_log + CDC · JSON API over a local socket
Terminal substrate
PTYs, worktrees, agent detection, session persistence
Headless Rust · Osade doesn’t reimplement terminals
Local-first
Local-first, and specific about it.
Loopback only
The daemon binds 127.0.0.1. There is no remote mode, no hosted service, no multi-tenant anything.
Tokens in the keychain
GitHub tokens live in the OS keychain via Electron safeStorage, held in memory by the daemon, never written to a config file.
One directory
Everything Osade writes lives in ~/.osade (%USERPROFILE%\.osade on Windows). Delete it and it’s as if you never ran it.
Reuses your gh login
Already have gh auth login? Osade reuses it instead of asking you to authorize a second OAuth app.
macOS, Linux and Windows.
Two things worth knowing if you read the code
There is no status column.
Task status is a pure function over durable facts — what the substrate observed, what verification returned, what GitHub reported — recomputed on every read. A flaky probe can’t kill a live agent.
There is one event path.
Every change reaches the UI through a SQLite trigger into change_log. If the UI didn’t update, the write didn’t go through the database.
Both are the kind of decision that’s cheap on day one and impossible to retrofit.
Status
Early and moving fast. Usable, not stable.
Working today
- chat-driven agent launch
- multi-agent fan-out
- worktree isolation
- derived status
- verification plans and the failure loop
- approval gates
- checkpoints and undo
- GitHub issue import and gated PR writes
- triage tasks
- the conventions miner and context injection
- layered memory
Not yet
- organization workspaces and the cross-repo ledger
- network egress enforcement
- the embedded terminal surface — watching an agent live opens a real terminal client for now (a deliberate deferral, ADR 0001)
FAQFrequently
Frequently
asked questions
What Osade is, what it refuses to do on its own, and what already works today.
No. Osade doesn’t ship a model or an agent — it’s the environment around the agents you already pay for. It drives the agent CLIs already on your PATH, so switching agents doesn’t change your workflow.
Contributors
Built by the community.
Every commit, review, and idea here comes from a person. Live from GitHub, agents and bots filtered out.