🦀 v0.5.0 · beta · MIT licensed

Gajae Code

Encode intention. Decode software.

An external coding-agent harness for interviews, reviewed plans, tmux-native execution, and durable verification. Run gjc from any repo or worktree and give your agent a small, explicit workflow surface.

shape · interview act · reviewed plans prove · evidence
Gajae Code autonomous coding-agent hero illustration
What is Gajae Code?

A focused harness, not a hidden plugin

Gajae Code (gjc) runs from the repository or worktree you choose, then gives the agent a deliberately small workflow: clarify before guessing, plan before mutation, and track every goal to completion with evidence.

It runs beside your existing tools — start it alongside Codex CLI, Claude Code, OpenCode, or Claw Code when you want structured planning, persistent evidence, tmux-backed workers, or an isolated worktree.

recommended workflow
# run gjc beside your repo or in a worktree
$ gjc --tmux --worktree ../my-task

# inside the session: shape -> act -> prove
> /skill:deep-interview # clarify intent
> /skill:ralplan        # plan & critique
> gjc ultragoal create-goals --brief-file plan.md
> gjc ultragoal complete-goals
The method

Shape · Act · Prove

One small loop, done well. No sprawling skill zoo — Gajae Code improves by making this method better.

01 — Shape

Interview before guessing

deep-interview turns vague requests into concrete requirements, boundaries, and explicit non-goals before any code is touched.

02 — Act

Plan before mutation

ralplan builds and critiques the implementation plan, then ultragoal carries the approved plan through execution with tmux-backed workers when parallelism helps.

03 — Prove

Finish with evidence

ultragoal tracks goals, revisions, checks, and completion evidence so a finished task ships with a verifiable trail, not a hopeful claim.

Workflow surface

A path you can read

The default workflow is intentionally explicit. You always know what stage you are in.

deep-interview

Clarify ambiguous requirements before planning or code changes.

ralplan

Build and critique an implementation plan before mutation.

ultragoal

Track goals through execution, revision, verification, and evidence.

team (optional)

Coordinate tmux-backed workers when parallel execution is worth it.

Capabilities

Built for reviewable autonomy

Everything you need to run an agent you can actually trust with a repository.

Interview-first intent

Requirements are clarified up front with deep-interview, so the agent works from a shared, concrete understanding instead of a guess.

Reviewed plans

ralplan drafts and critiques the approach through planner, architect, and critic perspectives before a single file is mutated.

Durable evidence

ultragoal records goals, revisions, checks, and completion evidence under .gjc/ — a verifiable trail for every task.

tmux-native execution

Run a leader session with --tmux and coordinate workers without losing visibility into what each lane is doing.

Worktree isolation

Point gjc at an isolated git worktree for risky or reviewable work, keeping your primary checkout clean.

Remote control plane

Drive sessions through bounded RPC/bridge surfaces, Hermes-compatible MCP coordination, and a gateway-scoped Remote design that keeps phone clients out of raw transcript, shell, and system-prompt authority.

Architecture

A layered runtime

From CLI launch to model streams, every layer has a clear responsibility.

CLI & modescoding-agent
The gjc binary registers commands (setup, deep-interview, ralplan, ultragoal, team) and dispatches interactive, print, RPC, and bridge modes.
Agent runtimeagent
A stateful turn loop transforms context, calls the model stream, executes tool calls, appends results, and emits lifecycle events.
Provider boundaryai
A model registry, provider implementations, auth, streaming, usage accounting, and retry/overflow handling sit behind one clean interface.
Toolsread · edit · bash · lsp
A built-in tool registry for file, code, and runtime operations — reading, editing, AST tools, search, LSP, the browser, subagents, and more.
Native & TUInatives · tui
Rust N-API helpers accelerate search, diff, syntax, and shell work; the terminal UI framework renders the interactive experience.

Explore the architecture →

Get started

Up and running in two steps

Install with Bun, then launch in your repository.

# 1 · install globally with Bun
bun install -g gajae-code
# 2 · verify the install
gjc --version && gjc --smoke-test
# 3 · launch in the current checkout
gjc
# 4 · or use a tmux-backed worktree
gjc --tmux --worktree ../my-task-worktree

Full getting-started guide →   Also available as @gajae-code/coding-agent.

Workflow surface

Four skills, four role agents

A small, fixed surface — no default skill sprawl.

Workflow skills

SkillWhat it does
deep-interviewClarifies ambiguous requirements before planning or code changes.
ralplanBuilds and critiques an implementation plan before mutation.
ultragoalTracks goals through execution, revision, verification, and evidence.
teamCoordinates tmux-backed workers when parallel execution is worth it.

Role agents

AgentWhat it does
executorBounded implementation, fixes, and refactors.
architectRead-only architecture and code-review assessment.
plannerRead-only sequencing and acceptance criteria.
criticRead-only plan critique and actionability review.

Skills reference →

Safety & proof

Trust comes from evidence

Autonomy is only useful when the result is reviewable. Gajae Code is built to leave a trail.

Plan-before-mutation

Approaches are reviewed and critiqued before any file changes, reducing wasted runs and surprise edits.

Completion evidence

Goals, revisions, checks, and verification results are recorded as durable artifacts you can read after the fact.

Isolated worktrees

Risky work runs in a dedicated git worktree, so your primary checkout stays clean and the diff stays scoped.

Fail-closed remote control

Bridge mode is HTTPS-only with a mandatory bearer token, and session-control endpoints are disabled by default.

How receipts & proof work →

Documentation

Dive deeper

Guides and references for every layer of Gajae Code.

Getting Started

Install, launch, and run your first shape → act → prove loop.

Architecture

How the CLI, agent loop, provider boundary, and tools fit together.

The Harness

Running gjc as an external runner beside your other agents.

Bridge & RPC

The remote-control surfaces: stdio RPC and the fail-closed HTTPS bridge.

Skills & Agents

The four workflow skills and four role agents in detail.

Receipts & Proof

The evidence model behind durable, verifiable completion.

Give your agent a workflow it can prove

Install Gajae Code, run it beside the tools you already use, and ship work with a trail you can read.