Interview-first intent
Requirements are clarified up front with deep-interview, so the agent works from a shared, concrete understanding instead of a guess.
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.
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.
# 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
One small loop, done well. No sprawling skill zoo — Gajae Code improves by making this method better.
deep-interview turns vague requests into concrete requirements, boundaries, and explicit non-goals before any code is touched.
ralplan builds and critiques the implementation plan, then ultragoal carries the approved plan through execution with tmux-backed workers when parallelism helps.
ultragoal tracks goals, revisions, checks, and completion evidence so a finished task ships with a verifiable trail, not a hopeful claim.
The default workflow is intentionally explicit. You always know what stage you are in.
Clarify ambiguous requirements before planning or code changes.
Build and critique an implementation plan before mutation.
Track goals through execution, revision, verification, and evidence.
Coordinate tmux-backed workers when parallel execution is worth it.
Everything you need to run an agent you can actually trust with a repository.
Requirements are clarified up front with deep-interview, so the agent works from a shared, concrete understanding instead of a guess.
ralplan drafts and critiques the approach through planner, architect, and critic perspectives before a single file is mutated.
ultragoal records goals, revisions, checks, and completion evidence under .gjc/ — a verifiable trail for every task.
Run a leader session with --tmux and coordinate workers without losing visibility into what each lane is doing.
Point gjc at an isolated git worktree for risky or reviewable work, keeping your primary checkout clean.
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.
From CLI launch to model streams, every layer has a clear responsibility.
gjc binary registers commands (setup, deep-interview, ralplan, ultragoal, team) and dispatches interactive, print, RPC, and bridge modes.Install with Bun, then launch in your repository.
bun install -g gajae-codegjc --version && gjc --smoke-testgjcgjc --tmux --worktree ../my-task-worktree
Full getting-started guide →
Also available as @gajae-code/coding-agent.
A small, fixed surface — no default skill sprawl.
| Skill | What it does |
|---|---|
deep-interview | Clarifies ambiguous requirements before planning or code changes. |
ralplan | Builds and critiques an implementation plan before mutation. |
ultragoal | Tracks goals through execution, revision, verification, and evidence. |
team | Coordinates tmux-backed workers when parallel execution is worth it. |
| Agent | What it does |
|---|---|
executor | Bounded implementation, fixes, and refactors. |
architect | Read-only architecture and code-review assessment. |
planner | Read-only sequencing and acceptance criteria. |
critic | Read-only plan critique and actionability review. |
Autonomy is only useful when the result is reviewable. Gajae Code is built to leave a trail.
Approaches are reviewed and critiqued before any file changes, reducing wasted runs and surprise edits.
Goals, revisions, checks, and verification results are recorded as durable artifacts you can read after the fact.
Risky work runs in a dedicated git worktree, so your primary checkout stays clean and the diff stays scoped.
Bridge mode is HTTPS-only with a mandatory bearer token, and session-control endpoints are disabled by default.
Guides and references for every layer of Gajae Code.
Install, launch, and run your first shape → act → prove loop.
How the CLI, agent loop, provider boundary, and tools fit together.
Running gjc as an external runner beside your other agents.
The remote-control surfaces: stdio RPC and the fail-closed HTTPS bridge.
The four workflow skills and four role agents in detail.
The evidence model behind durable, verifiable completion.
Install Gajae Code, run it beside the tools you already use, and ship work with a trail you can read.