@selesai/code

Your AI coding team. Built to finish. Yours to shape.

Documentation · Get started · Get model access on token.in · Report an issue

Your coding agent should do more than write code. It should remember how you work, bring in help when you ask, find answers instead of guessing, and keep going without making you repeat the whole story.

Selesai brings that together in one install. An AI coding agent for your terminal, with built-in memory, a team of specialist agents, agent-to-agent messaging, live web research, public code search, recovery tools, and 30+ ready-to-use skills.

And you can make it yours just by asking. Change how it looks, how it works, which models do which jobs, or teach it a workflow your team uses every day. Selesai can help configure and extend the harness itself, not just edit your project.

Not a bare agent and a weekend of extension setup. A workspace built to help you finish.

Use your preferred model provider, a local model, or an OpenAI-compatible endpoint. Connect token.in for model access and Sai-powered helpers, including relevance-based memory recall and code discovery. Some helpers require TokenIn even if your main coding model comes from another provider. See what needs TokenIn →

Built on the extensible Pi coding agent. The extensions below ship with Selesai—not as a shopping list of plugins you have to assemble yourself.

Quick install

Install the latest published package:

npm install -g @selesai/code
selesai

Run once without a global install:

npx @selesai/code

Or install the latest main branch directly from GitHub:

npm install -g github:SelesaiInTech/selesai-code

Start with a task:

selesai "Explain this repository and tell me how to run its checks"

Run a non-interactive request:

selesai -p "Review the current git diff without editing files"

Selesai stores user state in ~/.selesai/agent/ and project-local settings and resources in ./.selesai/.

📖 Read the full getting-started guide →

Not just more extensions. Fewer things you have to do yourself.

Your harness. Your rules. Just ask.

You don't have to learn an extension API to ask for a better tool.

Want a quieter terminal? A reviewer that follows your team's checklist? A shortcut for your release routine? Tell Selesai what you want. It can consult its shipped documentation and examples, update configuration, or help build the skill, agent, theme, or extension that makes it happen.

Make my terminal cleaner. Keep Git status and cost visible, hide the noise.
Create a reviewer agent that checks our payment code against this checklist.
Use a cheaper model for scouting, but keep my main model for difficult decisions.
Turn our release checklist into a reusable skill for this project.
Add a command that runs our checks and summarizes what failed.

Make a change for one project, or keep it across your work. Choose your models, shape your specialist team, connect your own tools, and keep the parts of the bundled workspace you find useful.

Start with a complete workspace. Keep shaping it into your workspace. Custom extensions are real local code: review and test them before relying on them, and reload when a change requires it.

Customization guide → · Configuration →

The more you use it, the less you have to explain

Stop teaching your agent the same lesson twice.

Selesai's persistent memory saves preferences, corrections, project facts, and reusable lessons across sessions. Tell it how you like tests written. Correct an assumption about your architecture. That knowledge can be there the next time you work—not buried in a chat you have to find yourself.

Past conversations are searchable too. Ask “What did we decide about authentication?” instead of reconstructing the decision from scratch.

Remember: this project uses pnpm, and every bug fix needs a regression test.
What did we decide about the database migration last time?

This is how Selesai gets smarter about you and your projects: saved knowledge and recall, not retraining the underlying model. You can inspect and manage what it remembers with /memory-insights.

Explore persistent memory →

One agent is useful. A team can move faster—and cost less.

Don't make one expensive model do every job.

With subagents, you can ask Selesai to split the work: one agent maps the code, another researches the approach, and reviewers check independent concerns in parallel. Keep background work moving while you continue with the main agent.

You can choose different models for different jobs. Keep a stronger model on architecture or difficult reasoning, and assign focused work to a lower-cost model, such as an available DeepSeek model. Match the model to the job, not every job to the most expensive model.

Delegate a scan of the authentication code to a scout.
Run parallel reviewers for correctness, missing tests, and unnecessary complexity.
Use a lower-cost DeepSeek model for the focused research task,
then bring the findings back here for review.

You stay in control: delegation happens when you authorize it, and you can inspect progress, steer agents, or stop a run. Independent work can finish sooner; savings depend on model prices, task size, and coordination overhead. More agents alone does not guarantee a lower bill.

Explore subagents →

Let your agents talk. Stop being the middleman.

Working on a frontend in one directory and an API in another? You shouldn't have to carry every question and answer between them.

Intercom lets running Selesai sessions on the same machine discover and message each other. Just ask your agent to talk to the agent working in the other directory.

Use Intercom to find the agent working in /projects/backend.
Ask it what the checkout endpoint expects before we build the form.

The agents can exchange questions, replies, and context while you focus on the result. Open /intercom to see connected sessions, or give a session a memorable name with /alias backend.

Intercom connects existing local sessions; it doesn't start a new agent or reach agents on another machine.

Explore Intercom →

Answers from today's sources. Examples from real code.

Less guessing. Less tab-hopping.

• Built-in web research finds current documentation, compares sources, and brings the findings back into the task. It can use a browser when a page needs rendering.
• Public code search with grep.app finds how people actually use a library across public GitHub repositories, then reads the relevant source. Move from “this API probably works like this” to a concrete implementation you can inspect.
• Interactive questions bring important choices to you in a clear form, instead of letting the agent silently invent requirements.

Check the current migration guide before upgrading this dependency.
Find real GitHub examples of how this library handles retries.
Ask me about the trade-offs before choosing the database.

Web research supports keyless search; some backends need credentials, and browser-rendered pages need a supported browser. Public code search covers public repositories, not private code. Sources still need judgment—not blind copying.

Web research → · Public code search →

Find the right code before changing the wrong thing

Big repository? Graft gives the agent a map of your code: where behavior lives, what calls it, and what else a change might affect. Less wandering through files. More attention on the code that matters.

Sai adds focused second opinions and plain-language code discovery: help classify a failure or find “where retry backoff is configured,” without loading every candidate file into the main conversation.

Find where checkout totals are calculated and what depends on them.
Before changing this shared function, check which callers could be affected.

Graft builds its repository map on first use and refreshes it after edits. Its deeper analysis uses your active model; a structural-only build can stay offline. Sai needs Token-In access. Both help the agent investigate; neither replaces reading the source and running checks.

Graft → · Sai →

Spend less on repeating context. More on solving the problem.

A better-informed agent shouldn't need your entire history to make its next move.

Memory brings back useful decisions instead of making you explain them again. Graft helps locate relevant code instead of reading the whole repository. Compact command output and on-demand skills leave more room for the actual task. Smaller models can handle focused helper work while your main model concentrates on harder decisions.

The benefit isn't just fewer tokens. It's better awareness: your conventions, past decisions, relevant code, and the consequences of a change. That gives the agent a better basis for its next action, not just a shorter prompt.

Less unnecessary context can stretch a token-metered plan further and reduce usage-based spend. It doesn't automatically extend a subscription limited by requests or time.

The economics we're aiming for: under US$1/month for lightweight Sai helper calls at light usage, and up to 50% lower token spend in context-heavy workflows. These are illustrative budget and savings targets, not measured averages, benchmarks, or guarantees. The helper budget excludes your main coding model, subagents, image generation, and deep graph builds. Actual costs depend on model prices, repository size, helper frequency, caching, and how much repeated context is avoided; helper calls and indexing add their own cost.

Connect TokenIn and see what's included →

A wrong turn shouldn't mean starting over

Keep your momentum—even when the plan changes.

• Undo rolls back tracked file edits from the last turn. Mutating shell commands are flagged, not automatically reversed.
• Session branches let you return to an earlier conversation and explore another approach. Branching the conversation alone does not roll back files.
• Handoff carries a summary into a fresh session, so a long conversation doesn't have to become permanent baggage. Use /handoff-new to continue with the important context.
• Context reminders warn when the conversation is getting large, before you keep adding more history to every request.

Your original session remains available. Try another approach without throwing away the whole conversation.

Explore recovery and continuity →

Less noise on screen. More visibility into the work.

See what changed, what's running, and what you're spending.

Selesai's fullscreen terminal workspace keeps your editor and status visible while the conversation scrolls. Zentui lets you shape the workspace; Tool Display keeps tool output compact and file changes readable.

Live model and subagent throughput, token usage, context usage, Git state, and session costs help you see what's happening instead of guessing. Cost reconciliation uses provider-reported billed amounts where available; otherwise costs remain estimates.

Prefer traditional scrolling terminal output? Switch with --tui-mode regular or in /settings.

Explore the terminal workspace →

The small things that save you work, every day

The rest of the bundled stack has a job too:

These are maintained together in src/extensions/ and shipped with the application. Bundled means no separate Selesai extension install; external services, model access, and some runtimes still have their own requirements.

Stop writing the perfect prompt. Start with the right skill.

“Make it look better.” “Review this properly.” “Don't stop halfway.” You shouldn't have to explain what good means from scratch every time.

Selesai includes 32 built-in skills: reusable playbooks for better design, sharper decisions, simpler code, and work that actually gets checked. Choose the outcome you need, then add your brief.

$taste Build a landing page for this product that doesn't look like an AI template.
$design-references Find a design direction inspired by Linear, adapted to our brand.
$grill-me Challenge this feature idea before we spend a week building it.
$plan-todo Turn what we've agreed into a plan someone else can execute.
$unlazy Implement this plan and verify every agreed outcome before calling it done.

Type $ to find a skill and insert $skill-name into your prompt. You can combine skills, such as $redesign $web-design-guidelines, or ask Selesai to create a new one for your workflow.

🎨 Make it look designed, not generated

A working interface isn't the same as a product people want to use. These skills give the agent a design direction, concrete standards, and a way to check its own work.

🖼️ Give the product a visual identity before coding it

Image generation needs an authenticated image model; generated assets may need refinement before production. Google Stitch access and web-based reference lookups have their own service requirements.

📋 Turn “we should build this” into a plan you can hand off

Need to challenge a big decision? The subagent extension also ships the council-mode playbook, available through /council. Advisors develop independent recommendations, challenge important disagreements, and return a decision memo. Get more than one perspective without an endless agent debate. This is an additional packaged workflow, separate from the 32 skills above.

🧹 Get the result without inheriting unnecessary complexity

🛠️ Make the next change easier, not just this one

✅ Replace “done” with evidence

📤 Keep the progress. Leave the oversized conversation behind.

🎤 Find the expensive assumptions before you build them

🤖 Test what people actually click

Every playbook is readable and editable. Use the bundled starting point, adapt it, or ask Selesai to create one around your team's way of working.

code-review-and-quality and code-simplification are adapted from addyosmani/agent-skills (MIT). Shared references and the upstream license ship in src/skills/references/.

Keep your model. Unlock more with TokenIn.

Your main model does the work. Lightweight helpers give it better context.

You can use Selesai with other model providers. Adding a token.in account unlocks the bundled TokenIn-powered Sai helpers without requiring you to switch your main coding model. Or use TokenIn for model access too.

Here's the difference, before you install:

The idea: a small helper budget can save expensive main-model work. The sub-dollar helper budget and up-to-50% savings target above are estimates to validate against your workload, not a flat-rate bundle or a promise about your bill. Deep graph analysis uses the selected model and is billed separately from lightweight Sai calls.

On the first interactive launch, Selesai can open the token.in dashboard and guide you through connecting the token. You can manage more than one account later from the TUI:

Saved accounts support automatic failover for authentication, rate-limit, and quota failures. Credentials stay in Selesai's local auth storage; never commit auth.json, tokenin-auth.json, or a token to source control.

📖 Token onboarding guide →

Built on Pi. Still yours to customize.

You get the bundled workspace without giving up Pi's extensibility or model choice:

• terminal tools for reading, searching, editing, writing, and running commands;
• multiple model providers, API keys, OAuth, thinking levels, image input, retries, and custom endpoints;
• persistent sessions with resume, fork, tree navigation, compaction, import, and export;
• interactive, print, JSON event-stream, and RPC modes;
• TypeScript extensions, skills, prompt templates, themes, packages, and an embeddable Node.js SDK;
• project trust and configurable resource loading.

Selesai is a local agent and runs with the permissions of the user who starts it. Project trust controls loading of project resources; it is not a sandbox. Use a container, VM, or other operating-system isolation for untrusted or unattended work.

📖 Security guide →

Everyday commands

Inside the TUI, type / for command completion. Common commands include /model, /settings, /resume, /tree, /fork, /compact, /tokenin, /export, /reload, and /hotkeys.

Documentation

The documentation is available in both English and Bahasa Indonesia at selesaiintech.github.io/selesai-code.

The repository also contains the Pi-compatible CLI, provider, model, extension, SDK, setting, session, and security references under docs/.

Repository map

src/
  core/        agent runtime, sessions, tools, packages, and extension loading
  modes/       interactive TUI, print, JSON, and RPC modes
  extensions/  bundled Selesai extensions and tests
  skills/      built-in skill playbooks
  themes/      terminal themes
  defaults/    first-run settings and model catalogue

doc-web/       bilingual documentation website
docs/          Pi-compatible technical references
examples/      extension and SDK examples
test/          cross-cutting tests

Development

Clone the repository and install dependencies:

git clone https://github.com/SelesaiInTech/selesai-code.git
cd selesai-code
npm install

Build and verify the CLI:

npm run build
node dist/cli.js --help
node dist/cli.js --version
npm test

Run from source during development:

npm run dev

Changes to bundled extensions belong in src/extensions/; the build copies them to dist/extensions/ for the published package. Built-in skills live in src/skills/ and are copied to dist/skills/.

Documentation development

cd doc-web
npm install
npm run dev

Run npm run verify inside doc-web/ before publishing documentation changes.

Contributing

Issues and pull requests are welcome.

1. Search existing issues before opening a new one.
2. Keep changes focused and explain the user-visible behavior.
3. Add or update regression coverage for executable changes.
4. Run npm run build and the relevant tests locally.
5. Keep Selesai config paths (~/.selesai/agent/ and .selesai/) aligned across code, tests, and documentation.
6. Update the bilingual documentation when a public capability or setting changes.

When changing a bundled extension, prefer the existing Selesai runtime and installed dependencies before adding another package. Preserve upstream attribution for adapted code and call out security-sensitive behavior clearly in the pull request.

Acknowledgements

Selesai is built on the excellent Pi coding agent and includes adapted, in-tree components from the broader Pi and open-source agent ecosystem. Component-level attribution and license notices remain with their respective source files and packages.

Built and maintained by SelesaiInTech.