Repository navigation
Releases
rumbo 0.6.0
Configuration is one thing to learn. Everything rumbo keeps is in files you
can read: what you chose in one config.yaml, and each session in a
directory of its own. Every setting is changed the same way, name=value,
is checked before it is kept, and rumbo config shows all of it with where
each value comes from. The model a new session starts with is now each
provider's own. Sessions and settings stored by 0.5.0 and earlier are not
carried over.
Configuration
- Every setting is changed as
name=value, and an empty value gives it
back to its default:rumbo system set max_turns=90,rumbo provider set anthropic effort=high,rumbo frontend set tui theme=plain, and in the
terminal UI/system-set,/provider-set, and/session-set, whose
menus offer the values each setting takes. Several changes go in one
command line, and none is kept unless all are right. - The model is now each provider's own, and
default_modelis gone:
rumbo provider set anthropic model=claude-opus-5-5. A new session starts
with the default provider and its model, andrumbo -p chatgptstarts
with chatgpt's, without-m. A provider with no model set still opens the
terminal UI, where/usechooses one; a task is refused until there is
one, saying how to choose it.rumbo provider models <name>lists the
models a provider offers. - A value is checked before it is kept. A provider is asked what it has: a
name it does not have, such as a misspelledcontxt_window, a value of
another type, or one not among those it lists, such asapi=bogus, is
refused with what it takes, and the provider is started with the change,
which is not kept if it does not start. Values are read as the setting's
type asks, soeffort=3is the text "3". The options a session chooses,
with-oor/session-set, are checked the same way. A front end cannot
be started without its terminal, so what it is given is checked when it
next starts. rumbo config, and/configin the terminal UI, show what is set and
what applies, each value with where it comes from: the session,
config.yaml, rumbo's default, or how rumbo has a built-in provider. It
starts nothing.rumbo provider show <name>, and/provider-show, start a
provider and show each of its settings, its own defaults included, with
what each is and the values it takes; in the terminal UI, without a name,
the session's provider, with what the session chose over the rest.rumbo systemshows the system settings;rumbo system list,get, and
unset,rumbo provider configandoptions, andrumbo frontend configsay what took their place.- The terminal UI has fewer commands:
/system,/system-unset,
/system-keys,/session-options,/option-values,/provider-config,
/provider-options, and its own/optionsare gone, into/config,
/system-set,/session-set,/provider-set, and/provider-show. Its
status bar says when there is no model yet. A color of its configuration
can be written as a number, such ascolor_code: 214.
Storage
- What you choose is kept in
~/.config/rumbo/config.yaml
(~/Library/Application Support/rumbo/config.yamlon macOS): the system
settings undersystem, and what you chose for each provider and front
end underprovidersandfrontends, a provider's model beside its
configuration. It holds only what you set, never a default, and you can
edit it. rumbo changes it one value at a time and leaves the rest, your
comments included, as you wrote it. A name it does not know there, or a
value of the wrong shape, stops it and says the line. - Each session is a directory,
~/.local/share/rumbo/sessions/<id>/:
session.jsonsays what it is and what it chose, andentries.jsonl
holds its history, one entry to a line, asrumbo logprints it. - Sessions and settings from 0.5.0 and earlier are not read. rumbo no
longer uses SQLite, and~/.local/share/rumbo/rumbo.dbis left where it
is, untouched. Set your defaults and register your own providers again.
To keep the record of an earlier session, print it with the version that
made it:rumbo log <session>. RUMBO_DBis gone.RUMBO_CONFIGnames the configuration file, and
RUMBO_DATAthe directory the sessions are kept in.
Providers
- A provider has one configuration, and the value you set for one of its
options is a setting of it like any other:rumbo provider set anthropic effort=highgives every session that effort unless it chooses another
with-oor/session-set. - Only what you choose for a provider or a front end is kept. Its defaults
are no longer copied next to it the first time it starts, so a default a
new version changes reaches you unless you chose otherwise. An option
nobody chose is no longer sent with each request as its empty default. - The built-in providers and front ends are always there, without being
registered.rumbo provider rm openairemoves what you set for it and
leaves it as rumbo has it; a provider you add under the same name takes
its place.
Protocols
- A provider can describe the fields of its configuration, as
fields,
the way it describes its options, each with its default. rumbo shows them
and checks against them what a person sets. The built-in providers
describe theirs. - A function of the host can be marked
lists: it is there to list the
values a parameter takes, and a front end need not offer it as a command. - The
modela front end is told of atinitializeis empty while
nothing chose one.
rumbo 0.5.0
The model is told of your skills. rumbo says how each session stands,
renames and prunes sessions, lists those of every project, and prints the
request any turn sent. It tells you when a request misses the provider's
cache, and summarizes a conversation at 80% of the model's context however
large it is.
Host
- The model is told of your skills, in the Agent Skills format: each
SKILL.mdin~/.config/rumbo/skills/<name>/(~/Library/Application Support/rumbo/skills/<name>/on macOS), and in a project's
.agents/skills/<name>/. It gets the name and the description of each,
and reads the skill itself when a task needs it. A project's skill
replaces one of yours with the same name.rumbo skills, or/skills
in the terminal UI, lists those the model is told of where you are, and
says why one is left out, such as a frontmatter without a description.
Sessions
- rumbo says when a request misses the provider's cache: when the provider
read less of it than the request before left in its cache, it tells you
how much it read, and how much counted as new input instead. A pause
longer than the cache keeps a conversation, a few minutes with Claude,
is the usual cause. Opening a session shows its earlier misses too. - A conversation is summarized at 80% of the model's context however large
it is, andrumbo system listshowscompact_atas80%. It used to be
summarized at 150,000 tokens at most, which was 15% of a context of a
million tokens, such as Claude Opus's.rumbo system set compact_at 15%
brings that back for such a model. rumbo sessionssays how each session stands: how its last run ended,
or that a rumbo process is using it, its turns, and the tokens they took.
-alllists the sessions of every project. Its output now has a header
and aligned columns, with the title last. The list of/opensays how
each session stands and its turns too.- Sessions can be renamed, with
/renameorrumbo sessions rename, and
deleted several at once, withrumbo sessions rm, or by age, with
/prune 30dorrumbo sessions prune 30d. Both list the sessions
first, and delete them when givenyes:/prune 30d yes, or
rumbo sessions prune -yes 30d. A session in use by a rumbo process is
kept. rumbo request <session> [turn]prints the request a turn sent the
provider, exactly as it was sent, rebuilt from the session.- Each response records the output limit its request set, how long the
provider took, and the version of rumbo; each tool result, how long the
tool took.rumbo logshows them. - A host whose session was deleted by another rumbo process says so when
given a task, instead of failing with a database error.
Front ends
- A front end can show the sessions of every project:
projectslists the
projects that have sessions, most recently used first, andsessions
lists another project's with itsproject. In the terminal UI they are
/projectsand/sessions <project>. - The input tokens the terminal UI and
plaincount now include those the
provider wrote to its cache, as/statusdoes. With Claude, which writes
nearly all of each request there,inshowed almost nothing, and a
cache miss did not move it. - When it quits, the terminal UI leaves the command that continues its
session,rumbo -s <session>, under the conversation.
rumbo 0.4.0
A new built-in provider, chatgpt, uses your ChatGPT plan instead of an
API key. Requests to OpenAI's Responses API read much more from its
cache, and the effort in a provider's configuration now applies.
Providers
- A new built-in provider,
chatgpt, uses your ChatGPT plan instead of an
API key:/loginsigns in with ChatGPT in your browser, and over ssh you
paste the address the browser ends at. Its usage counts against your
plan;/accountand a usage limit say where to manage it. rumbo
registers it at its next start, andrumbo provider rm chatgptremoves
it for good. chatgpt, andopenaiwithapiset toresponses, read much more of
each request from OpenAI's cache: every request of a session now asks for
the server that cached its start. Before, about half of the requests of a
long run missed the cache and were paid for, or counted against a
ChatGPT plan, in full.- The
effortin a provider's configuration (rumbo provider config <name> effort=...) now applies inanthropic,openai, andchatgpt.
It was never sent: the empty option every request carries when nothing
is chosen replaced it. An effort chosen as an option, or in a session,
still wins over it.
rumbo 0.3.0
The terminal UI is new. It draws inline, in the terminal's own scrollback,
shows what the model writes as Markdown and each tool call as a block,
opens pickers for sessions, models, and option values, brings back what
you asked in any session, and can copy an answer and export a session.
Sessions can branch.
Terminal UI
- It draws inline, below what the terminal showed before, instead of
taking the whole screen: the conversation goes into the terminal's
scrollback, and only the part still changing is drawn again. - A slash opens a menu of the commands with what each does, and then of
what each takes, with what describes every value, such as a session's
title. It narrows as you type, by value or description; Tab or Enter take
a choice, and Enter on a command that needs nothing more sends it. - The input takes several lines: Alt-Enter, Shift-Enter, or Ctrl-J starts
a new one, and pasted text keeps its line breaks. - Up and Down bring back what you asked in any session of the project, not
only in this start, and Ctrl-R searches it. It comes from the sessions
themselves, so deleting a session removes it from there too; commands
are remembered until the terminal UI quits. - What the model writes shows as Markdown: headings, lists, quotes, code,
bold, italics, links, and tables lined up in columns. - A tool call shows with a spinner and its time while it works, then with
how it went: an edit with the lines it changed, a command with the start
of its output, or its exit status and the end of its output when it
failed. - A run ends with how long it took, its turns, and its tokens.
- Opening, branching to, or continuing a session (
/open,/branch,-c,
-s) shows what it holds, and the status bar counts that session's
context and tokens. - Enter on a command that still needs something opens the menu of what it
takes:/openlists the sessions, and/use openaithe models of
openai. After/session-options, the menu offers the values of the
provider's options, with those in force marked. - The status bar shows how full the context is as a bar, yellow past half
and red past four fifths, and how long a run has worked, and leaves out
what does not fit, the least needed first. - A run in the background that ends says what it took and how to open its
session. A run that ends, or a provider that asks something, while the
terminal is not in front rings the bell and sends a desktop notification
(OSC 9), in terminals that report their focus. /copyputs the model's last answer in the clipboard, and/copy code
its last code block, through the terminal (OSC 52), so it works over ssh./export [path]writes the session as Markdown, torumbo-<session>.md
in its directory unless a path is given, and never over a file.- Its colors can be chosen in its configuration:
rumbo frontend config tui theme=plainshows none,color_code=#d7875fchanges one, andNO_COLOR
is followed under the default theme,auto.
Sessions
- A session can branch:
/branchgoes on in a new session that starts
from the current one as it is, or as it was before one of your messages,
numbered as/branch-pointslists them. The first session stays as it
was, and can keep working at the same time. The files are not part of a
session, so a branch finds them as they are. /sessions,/status, andrumbo sessionssay which session a branch
came from.
Protocols
Both stay at version 1, and what is new in them is optional.
- A front end can ask the host, with
recall, what the person asked in the
project's sessions, newest first, to bring it back to its input. - A function that lists a parameter's values is called with what was given
for the parameters before it that it takes, so the values of one can
depend on another. - The host lists a provider's models,
provider-models, and the values its
options take,option-values, asking it;use,session-options, and
provider-optionslist their values with them. - For front ends written in Go,
protocol.DialFrontendConfiguredanswers
with the start configuration in force.
rumbo 0.2.0
Configuration is simpler: the system settings, and over them what each
session chooses. The built-in providers sign in with an API key, and
openai speaks OpenAI's Responses API. Some commands and settings have new
names; what you stored is carried over, but for values stored for one
project.
Settings
Settings are now kept apart by what they act on: the system, a session, or
a provider.
rumbo configis nowrumbo system, for the system settings:
default_provideranddefault_model, which new sessions start with,
frontend,max_turns,max_tokens, andcompact_at. Themodel
setting, which held both the provider and the model, is carried over to
the first two once.- Settings are the same everywhere: there are no project settings any more.
Those stored for one project are no longer read, andrumbo system list
shows them. compact_attakes a share of the model's context, such as80%, or0%
for never. One stored as a number of tokens stops rumbo, saying how to
change it.-pchooses the provider and-mthe model alone, which may hold a
slash:rumbo -p local -m qwen3-coder.-m provider/modelno longer
works. What-p,-m, and-ochoose is the session's, kept from one
start to the next, as/useand/session-optionsmake it.- A provider's options are its own, kept with its registration, no longer
theoptions.<provider>setting:rumbo provider options <name> effort=high, or/provider-optionsin the terminal UI. Those already
stored are carried over. - Every field of a provider's or a front end's configuration, and every
option of a provider, now has a value you can see in
rumbo provider showandrumbo provider list: the one you gave, or the
program's own default, which rumbo keeps the first time the program
starts.rumbo provider addstarts the provider, so one that does not
work is not registered. - In the terminal UI,
/helplists the commands by what they act on, and
some have new names:/system,/system-set,/system-unset, and
/system-keyswere/settings,/setting,/unset, and
/setting-keys;/provider-add,/provider-config,/provider-show,
and/provider-rmwere/register,/configure,/inspect, and
/unregister. On the command line,rumbo provider setand
rumbo frontend setare nowrumbo provider configand
rumbo frontend config. - A session keeps the provider options chosen in it, as it keeps its model:
/session-options effort=high. Changing its provider with/useleaves
them behind. The terminal UI's/set, whose choices lasted until it
closed, is gone. - A system setting or a provider's option you store applies to the next
run, without starting rumbo again. The default provider and model, and the
front end, still apply from the next start.
Providers
- The built-in providers sign in with an API key:
/loginasks for it,
checks it, and keeps it in~/.config/rumbo/credentials/, readable only
by you;/logoutremoves it, and/accountsays which credential is in
use. A key in the environment still comes first. - The built-in
openaiprovider offers aneffortoption, sent as
reasoning_effortonly when it is chosen:/session-options effort=high,
-o effort=high, oreffortin its configuration. The values depend on
the model. Likeanthropic, it now refuses options it does not describe. - The built-in
openaiprovider can speak OpenAI's Responses API, which
its reasoning models need to use tools with an effort, and theopenai
rumbo registers on a new installation does. One registered before keeps
Chat Completions untilrumbo provider config openai api=responses. It asks
the server to store nothing, and gives a model its own reasoning back,
encrypted. - In the terminal UI, what a provider's function answers in words shows
without quotes.
Protocols
Both stay at version 1, and what is new in them is optional.
- Each function of the host says what it acts on, in
group:system,
session, orprovider. - A provider's or a front end's answer to
initializemay carryconfig,
its configuration in force, with its default for every field it was not
given. rumbo keeps it with the registration. - Every option a provider describes has a
default, which may be empty
when that means the model decides.rumbo provider addsays which ones a
provider gives none for.
rumbo 0.1.0
The first release.
Host
- Works on a task until the model stops calling tools, with four tools:
read,write,edit, andbash, with a timeout or in the background. - Keeps each session as an append-only list of entries in SQLite, from which
every request sent to the model can be rebuilt, and keeps the start of
each request stable so providers can cache it. - Takes what you tell a run while it works, and resumes a run that failed,
was cancelled, or was cut short (-r). - Summarizes a conversation before it outgrows the model's context.
- Works in several sessions of a project at once, or in one with
-single,
and locks each session it works in. - Gives the model the environment and the
AGENTS.mdorCLAUDE.mdfiles
of the project and of the user. - Stores settings globally or per project, and checks each when it is
stored.
Providers
- The Agent Provider Protocol, version 1.
- Built in:
anthropicfor the Claude API, andopenaifor any server
compatible with OpenAI's Chat Completions. - Providers describe their models, options, and functions, and their
functions can talk with the person while they work.
Front ends
- The Agent Frontend Protocol, version 1, with the host's own functions
described as commands and a session's history told in events. - Built in:
tuifor terminals andplainfor pipes and scripts. rumbo serve, for a front end that starts rumbo itself.
Command line
rumbo version.- A lone word close to a command, such as
rumbo versoin, is refused
instead of being sent to the model as a task;rumbo -- wordsends it.