gjalla CLI

What the CLI does

The gjalla CLI turns your platform rules, skills, memory, and system context into one local harness for Claude Code, Codex, Cursor, Gemini, and more. Your agents do not need separate setup or separate copies of the truth.

• Installs natively: into the files, hooks, skill directories, and rule locations each agent already understands.
• Enforces process: process rules become real checks during the development workflow.
• Stays current: edit a rule or skill in the web app, then run gjalla sync; every supported agent picks it up without reinstalling.

After setup, you and your agent use it

Install and setup are the most human-centric part. After that, your agents are the main users: they recall memories, check rules, read system state, and record what they did, all through the same CLI.

When you do want to change something, you can use the portal, run a command yourself, or just ask your agent:

"Help me configure my gjalla rules. Show me what's active and
 let's add one for our API error format."

"Save what you just learned about our auth flow as a gjalla
 memory so the other agents know it too."

If you’re an agent, start here

Four commands orient you. Run them before you explore, not after.

gjalla rules show      # the constraints you are working within
gjalla memory show     # what earlier sessions learned the hard way
gjalla state show      # architecture, capabilities, data flows, tech stack
gjalla log             # what has changed about the system recently

That is the wake-up routine. It returns what you would otherwise reconstruct from ten or twenty file reads, plus the things no file can tell you: decisions and the reasoning behind them, constraints someone wrote down, and what other sessions already worked out. Reads are cache-first, so they work offline after a sync.

Intent to command

You are about to	Run
Start or resume work in a repo	gjalla rules show + gjalla memory show
Design a change	gjalla state show -c architecture
Check what a change touches	gjalla state impact
Learn something durable	gjalla memory save "<fact>" -n "<name>"
Record a step you completed	gjalla ledger mark <kind> --evidence k=v
Commit	gjalla attest --example, then gjalla check
See what needs attention	gjalla log --findings
Get unstuck, or suspect stale data	gjalla status, then gjalla sync

Process rules are compiled into your agent’s own hooks, so they stop a disallowed command before it runs rather than flagging it in review afterwards. You cannot talk your way past one, which is the point: it costs you a blocked command instead of a wasted implementation.

What you put back matters as much as what you read. See Attestations for the commit record and the ledger, and Shared agent memory for what is worth saving.

Installation

Install from PyPI:

pipx install gjalla

Sign in

The fastest way to authenticate is browser-backed login:

gjalla auth login

Once approved, the CLI can access every project your account can use. For CI, set GJALLA_API_KEY.

Set up a repo

Run setup from the repo root:

cd your-repo
gjalla setup

The wizard links the repo, installs hooks, configures MCP where available, and writes the native guidance files your agents read. Re-run it safely after upgrades or when you add a new agent.

Keep agents in sync

gjalla sync is the day-to-day refresh command. It pulls the latest platform rules, installs enabled skills into each agent’s native location, and distributes shared context locally.

gjalla sync

Change a rule in the web app, sync the repo, and the next agent session uses the new harness. No reinstall, no duplicate edits across tools.

Update the CLI

pip install --upgrade gjalla
# or if installed via pipx:
pipx upgrade gjalla

gjalla setup

Re-running setup refreshes the installed harness without replacing your project content.

Memory

Durable facts, saved once and recalled by every agent. Agents use these constantly.

gjalla memory show [<key>]

A compact index of what’s known, one memory in full by key, or a topic search with -q. Each memory shows its scope (personal, team, system, or project). Cache-first, so it works offline after a sync. Add --json for agents.

gjalla memory save “<fact>” -n “<name>”

Save a durable fact. Pass --scope team or --scope project to control who inherits it; personal is local-only under ~/.gjalla/user/.

gjalla memory archive / restore <key>

Recoverable lifecycle controls; hosted scopes require owner or admin authority.

Rules

gjalla rules show

The active rule set: constraints, principles, process rules, and decisions. The first command an agent should run in a new session.

gjalla rules check

Deterministically evaluate rules with machine-checkable configs against the staged change. Rules without an evaluable config are reported as unevaluated, never silently passed.

gjalla rules add -n “<name>” -d “<what>”

Add a rule from the terminal (or edit in the web app and sync down).

Skills

gjalla skills show [<slug>]

Browse the resolved skill set with each skill’s source and scope, or read one in full.

gjalla skills add

Add a skill for your team’s patterns. gjalla sync installs enabled skills into each agent’s native directory.

State & context

gjalla state show

Current architecture, capabilities, tech stack, and data flows. Use -c architecture to focus one section.

gjalla state impact

Preview what parts of the system a change may affect, before making it.

gjalla context show

Print an agent-ready bundle of rules, state, capabilities, and tech stack in one shot.

gjalla log

Semantic history: rules, architecture, capabilities, reviews, and commit records over time. Like git log, but for what changed about the system.

Add --findings for what reviews and drift detection have flagged, --since 7d to bound it, and --system <id> to interleave every project in a system.

Process & committing

gjalla spec new <slug>

Scaffold a change spec with current project context preloaded.

gjalla loop start <slug> / gjalla loop report

Bind work to a spec, then see the timeline of what actually happened: milestones, test runs, review rounds, and staged impact.

gjalla check

Run the commit gate manually. The installed hooks call this on every commit.

Setup & sync

gjalla setup

Install or refresh the repo harness: project link, hooks, MCP config, agent guidance, skills, and rule locations where supported.

gjalla sync

Refresh rules, skills, memory, and system context from the platform. Session-start hooks read the existing cache without network access; run gjalla sync to fetch newer hosted context.

gjalla auth login / gjalla status / gjalla project create

Sign in (browser-backed; --no-browser for headless), check install state, create and connect a project.

gjalla mcp serve / install

Serve or install the MCP bridge for agents and editors that support MCP.

Agent support matrix

Agent capabilities vary, but the model is the same: one gjalla harness, installed into each tool’s native surface where possible.

Agent	Guidance	Skills	Context	Memories alpha
Claude Code	✓	✓	✓	✓
OpenCode	✓	✓	✓	✓
Cursor	✓	✓	✓	n/a
Windsurf	✓	✓	✓	n/a
Codex CLI	✓	✓	✓	n/a
Gemini CLI	✓	✓	✓	n/a
Aider	n/a	n/a	✓	n/a
GitHub Copilot	✓	n/a	✓	n/a

• Guidance: repo-level instructions installed by gjalla setup.
• Skills: workflows installed by gjalla sync into supported native locations.
• Context: project rules and state available through CLI or MCP.
• Memories: alpha. Shared project facts distributed through sync where supported.

Custom hook managers

If husky, simple-git-hooks, or pre-commit.org owns your hooks, run gjalla setup --no-hooks and point your hook manager at the scripts setup writes:

# pre-commit:
bash scripts/gjalla-attestation-check.sh

# post-commit:
bash scripts/gjalla-post-commit-upload.sh