Core
Kompass Workflow infrastructure for AI coding agents
Navigate your way.
Manual steering, steered autonomy, or full autonomy. Kompass keeps AI coding agents on course with token-efficient, composable workflows.
Adapters
OpenCode today, more surfaces next
Integrations
GitHub workflows, tickets, PRs, review loops
expected run
$ /ask how does command config merging work?
# load only the relevant project context
# answer directly without drifting into implementation
> loaded config and command registry context
> returned a concise project-grounded answer
$ /branch docs site refresh
# summarize uncommitted work
# create a categorized branch name from the change themes
> created branch: docs/site-refresh
> switched from main to the new work branch
$ /commit
# inspect staged and unstaged changes
# generate a why-focused commit message
> staged relevant files
> created a new commit with generated message
$ /commit-and-push
# commit the current work
# push the branch upstream in one pass
> committed current changes
> pushed branch to origin
$ /dev implement the approved workflow in packages/core
# load ticket context only when the request looks like a ticket source
# edit only the relevant files and validate the result
> implemented focused code changes
> returned validation results and PR handoff notes
$ /learn how AGENTS.md conventions are used here
# inspect existing patterns in the repo
# extract reusable guidance into AGENTS.md targets
> summarized established conventions
> updated agent guidance where the pattern belongs
$ /reload
# refresh config, commands, agents, and tools
# use after changing kompass config or templates
> refreshed the active OpenCode project cache
> new config is ready without restarting
$ /pr/create
# summarize branch work and resolve ticket handling
# push if needed, then publish a structured PR
> created PR body with ticket, description, and checklist
> returned the PR URL and push status
$ /pr/fix
# load PR history and outstanding feedback
# review proposed fixes with the user unless auto mode was requested
> fixed requested issues on the branch
> posted replies to the relevant review threads
$ /pr/review
# load pr, reviews, comments, files, and diff context
# if the pr references a ticket, load that ticket too before reviewing
> added inline comments and review summary
> approved or requested changes based on the findings
$ /review
# auto-discover uncommitted or branch comparison scope
# return findings without mutating the working tree
> produced a concise branch review
> highlighted issues, risks, and follow-ups
$ /ship
# create a work branch when current changes are still on the base branch
# delegate commit and pr creation as a fast path to shipping
> moved the branch through commit and PR creation
> returned the final PR handoff
$ /rmslop
# inspect the branch for unnecessary complexity
# simplify code, prompts, and workflow glue where possible
> removed unnecessary code and duplication
> left a smaller, clearer diff
$ /todo @TODO.md
# load the todo list and keep orchestration local
# ask for plan approval before implementation starts
> completed the current todo item
> reported what is done, blocked, or next
$ /ticket/ask #128 what changed since the first draft?
# load the ticket plus discussion history
# answer with repo-aware context and post back to the ticket
> generated a contextual answer
> posted the response as a ticket comment
$ /ticket/create
# auto-discover current change comparison when no base was passed
# create a structured issue with checklist sections
> created a GitHub issue with scoped checklist items
> returned the new ticket reference
$ /ticket/dev #128
# load the ticket, create a plan, then execute the work
# keep ticket context attached throughout implementation
> produced an implementation plan and finished the requested work
> returned validation notes and PR-ready context
$ /ticket/plan #128 rollout the new review workflow
# load ticket context, comments, and attached constraints
# draft a scoped plan before any code changes happen
> created a detailed implementation plan
> stored the result as a reusable handoff
Why it feels different
Every layer is built to reduce wandering.
Modes that fit the moment
Manual steering when the details matter.
Keep the agent close, load only the right context, and move with precise commands instead of bloated prompts.
Guided autonomy
Delegate the leaves, keep orchestration local.
Kompass turns planning, implementation, and review into composable flows so agents stay inside the rails you define.
Cross-adapter direction
One workflow language across agent surfaces.
Shared commands, skills, and tools live in core packages while adapters expose them cleanly where developers already work.
Structured by design
A calm system underneath the agent surface.
`packages/core` holds the reusable workflows. Adapter packages expose the same operating model inside each coding agent. That means less reinvention, clearer reviews, and more consistent behavior from session to session.
- Planner, worker, navigator, and reviewer roles built for real repository work.
- Token-efficient command docs and components that can be reused across adapters.
- Structured PR, ticket, and change-loading tools that keep context grounded.
Shared core
Write the workflow once.
Commands, agents, components, tools, and skills live in `packages/core` so the operating model stays consistent.
Adapter surfaces
Expose it where developers already work.
Adapter packages translate the same workflow system into specific agent environments instead of reinventing the prompts.
GitHub automation
Keep tickets, reviews, and PRs inside the loop.
Planning, review, and shipping flows stay grounded through structured GitHub-aware tools and explicit checkpoints.