Repository navigation
Releases
llx 0.6.2
-
Update llx with
llx --updateafter installing it with the install script. Terminal
sessions check for a newer stable release in the background and show a note without
interrupting work or installing anything. SetLLX_UPDATE_CHECK=0to disable the notice. -
Updated the built-in model catalog, including GPT-6.2 Sol and GPT-6.2 Astra.
-
An answer's Markdown is read by flowdown, the
lab's library the parser grew into, in place of llx's own copy of it. Version 0.1.1 reads
horizontal rules between tabs and formulas such as$2 + 2 = 4$, and tells the model how
the forms are drawn. A long run of)after a bare address is read in linear time. -
--schemais checked by flowschema, the lab's
library the checker grew into, in place of llx's own copy of it. The messages and what is
checked are the same; a schema is compiled several times faster.
llx 0.6.1
- The project is Localix CLI, and its repository is
localixai/localix-cli. The command stays
llx. A release's archives arelocalix-cli-<target>.tar.gz, and each is also given under its
former name,llx-cli-<target>.tar.gz, so an installer of an earlier version still finds it.
The action islocalixai/localix-cli@v0(rsaryev/llx-cli@v0forwards to it), and the image of
a release isghcr.io/localixai/localix-cli:<version>. curl -fsSL https://llx.sh/install | shinstalls again. Since the site's installer looked
for the new archive names, it found none in 0.6.0; this release has them.- Examples:
secrets/, secrets kept out of an agent's context, a commit and a pull request, on two levels: the formats tokens are issued in, masked on your machine as[REDACTED:NAME], thenllx decideasked about what no format gives away (a password in a config, a token in a URL). As a Claude Code hook on a command's output, a gitpre-commithook and a CI job, each run for real.
llx 0.6.0
- An answer's steps, tabs and callouts are drawn as what they are. A quote that opens with a marker is a form:
> [!NOTE],[!TIP],[!IMPORTANT],[!WARNING]and[!CAUTION](GitHub's alerts) a callout behind a bar of its colour;> [!STEPS]over a numbered list, stages down a rail;> [!TABS]over headings, each variant under its label;> [!STATS]figures on one row, or a list where the row does not hold them;> [!PROS]and> [!CONS]lists by+and-;> [!DETAILS]a section under its title;> [!SOURCES]links by number. Before, each was a quote with[!NOTE]left in its text. A task's box stands where its bullet would, its text hanging under itself; an image shows its description and address, and a list written with blank lines between its items keeps them. A table too wide for the terminal gives its columns room by what they hold, as a browser does (a column of names stays narrow beside one of sentences), and rules its rows apart when they hold long text (half of them take three lines or more); code keeps its tabs as columns, four wide (they were shown as\t); a word and the punctuation that runs into it (`--flag`:) go to the next row together, and so do the words of a code span a row holds (`git reset --hard`is not broken in two); a link's underline ends with its last word, not with the space after it. The model is told the forms where its answer is drawn (a session,execat a terminal), by the package that reads them (markdown::prompt, in the context's<answer_format>); an answer that goes to a pipe, a file or--jsonis asked for none. The Markdown is read by llx's own parser (packages/markdown: every example of CommonMark 0.31.2 and of GitHub's tables, strikethrough, task lists and bare links, no dependency), in place ofpulldown-cmark. It is the one crate of the release built for speed (opt-level = 3, about 33 KB of the binary): an answer is read again as each piece of it arrives. Inexec, an answer drawn with no call before it is a blank row from the line that says how the run ended, as one after a call is. A call that joins the one before it under↳keeps its first row inside the screen; before, a row that filled the width under a bullet went two columns past it and broke in the middle of a word. The demo on llx.sh and the README's GIF are recorded again from real runs, with answers drawn as steps, tabs and a table among them. - An answer reads better in a terminal. Headings stand out by their weight (the first underlined, the second bold, the third bold and slanted), a list's bullet says how deep the list is (
•, then◦), and a task is✓or☐where its bullet would stand. A quote that ends with— Authornames its source under it; a picture's caption (the emphasised line right under it) stands under it. A fence that names its file (```ts src/app.tsortitle="…") is drawn under the name, adifforpatchfence in green and red by what its lines add and take away, a```treefence as a file tree with its branches, what is said of the names in one column; amermaidfence says it is a diagram. A formula ($x^2$,$$ … $$, amathfence) is written as the Unicode a terminal has,\frac{1}{k} \sum_{i=1}^{k} r_ias1/k ∑ᵢ₌₁ᵏ rᵢ, a block one set in on rows of its own; a price ($5) and a shell variable ($HOME) stay text. A footnote is its number where it is named and its text at the end. A step's name has a row of its own with what is said of it under it, and the numbers of a long chain end in one column; figures stand side by side, each number over what it counts; a source's address has a row of its own, whole whatever its name's length. A blank row stands only between two blocks that are drawn, and nesting deeper than the width holds is drawn flat rather than past the edge. The parser reads the formulas and the footnotes itself (Kind::Math,Kind::MathBlock,Kind::FootnoteRef,Kind::Footnotes). The model is told of the tree and diff fences, the file's name, the quote's source and how a formula is written, with the other forms. - Models on your own machine, and any host of chat completions. llx finds the servers that run local models and calls each for the models it says it runs: Ollama (
OLLAMA_HOST, else port 11434), LM Studio (1234), llama.cpp'sllama-server(8080), and any you name underlocalin~/.config/llx/settings.json({"name": "box", "url": "http://box.lan:8080"})./modellists those that answer underLocal:, beside the catalog's providers underCloud:(Local: none runningwhen none does);--provider ollama -m qwen3:8bnames one for a run;llx doctorsays which answer. No list of local models is built in: a server is asked each time, with the context each model is loaded with where it tells it (llama.cpp's/props, LM Studio's/api/v0/models, Ollama's/api/ps). A local model is asked to stream, so a reply its limit cut keeps its last call, with its usage and what it read from its cache; a reply is 8,192 tokens at most, a quarter of the context when that is less; no title is asked of it, as it answers one request at a time.LLX_LOCAL=0looks only for what the settings name. Any other OpenAI-compatible host, wherever it is, goes underhosts({"name": "work", "url": "https://llm.example/v1", "key": "…"}, withmodels,contextandoutputfor what it does not say itself): aHosts:tab of/modeland--provider work, called as any plain host with none of a local server's limits./loginadds a host too: its last row,Another host, asks the address, a name and the key, checks that it answers and saves it insettings.json. A name that is a provider's own is asked again at once, and never offered. A host at the address of a provider the catalog knows (OpenRouter's, Anthropic's) is called as that provider, with its models, prices, levels and prompt cache. A model such a host serves that the catalog knows under any provider (anthropic/claude-…behind a proxy, a vendor's model under its bare id) is called with what the catalog says of it: its levels, its limits, and the prompt-cache marks the models that need them take (a host that refuses the marks is asked again without); the context and reply the settings give still win. A field a host refuses by name (Unsupported parameter: …) is left out, or the reply's limit sent asmax_completion_tokenswhere it asks for that, and the request asked again; later requests to it go out so. A host the catalog does not know that says no cost for a request is priced from the catalog's entry of the model, where it has one: its vendor's price, which the host's own may differ from; a server on this machine costs nothing. A 429 that says the account has nothing left (Insufficient balance,insufficient_quota) is said at once, not asked three times. The cache counts are read as DeepSeek (prompt_cache_hit_tokens) and Anthropic-style proxies (cache_read_input_tokens,cache_creation_input_tokens) say them too. - A long session's request never goes a token past the limit. The size a conversation is held to was rounded down twice, the conversation's and the tools' descriptions', so a request could be one token larger than the limit it was fitted to; both are now rounded up.
llx 0.5.1
- The GitHub Action drops privileges on Ubuntu 26.04, today's
ubuntu-latest. Its sudo is sudo-rs, which ignores-E: the lockdown lost the run's directory and every run withprivileges: drop(the default on a hosted runner) ended not ready. The directory now goes to it as an argument, and the step's variables come back as they always did for those sudo resets. - The session redraws only what changed. A frame with nothing finished to print writes just the live rows that differ, and none when nothing does; before, every tick of the spinner erased and drew the whole live area again. The same session writes about a third of the bytes to the terminal.
- A mode switch says one short line,
Mode: plan. Read-only.; before, Shift+Tab printed the whole text the model is given, three rows forplan./modeand the modes/modeoffers read the same way. - A question's long descriptions go under their options, every option alike; before, a row that did not fit was wrapped on its own and the descriptions started at a different column on each row. The answer given is shown whole under
Asked, wrapped, no longer cut at the row's end. - A patch of one file does not name it twice:
Patched stats.py, then the diff, withoutM stats.pybetween them. - The
exectrace reads a call from the project, as the session does: a command's owncdinto the project and the project's path in its arguments are left out; before, each call began with rows of an absolute path. - A spawn's block says who was started and what for, in two rows at most; before, it printed the whole brief, a dozen rows for each agent. The agent's own view has the brief in full.
- An agent's step under the call running reads from the project too: no
cdinto the project, no absolute path; before, the row was cut before the command itself. - A model switch names the settings file from
~, as/statusdoes. /statuswrites the workspace and the key's file from~, and/usageshows a cost under a cent with four digits ($0.0003, not$0.000).- On Anthropic's API, a reply the output limit cut off no longer loses its last call. A tool's input is now streamed as the model writes it (
eager_input_streaming); before, the API held a long string back until it was whole, so a cutapply_patcharrived empty and the files it had written whole were never applied. - Anthropic's models write up to 64,000 tokens a reply at every level (or the model's own limit when smaller); before, 32,000 below
xhigh, where a reply that thought long was cut before its first call and lost whole. apply_patchreads a patch ended after each file as one patch: a*** End Patchbetween two files' sections, with or without a new*** Begin Patch, is a separator. Text after the end that starts no file is still refused, with its line.apply_patchtakes its text whatever else the model wrote beside it where it is offered as a function: a call with adescriptionnext to the patch was refused as "not JSON arguments", and the model wrote the patch again.- A patch cut off while it rewrote a file keeps that file. A
*** Delete Filefollowed by an*** Add Fileof the same path, the cut falling in the new text, deleted the file and wrote nothing; the pair is now left out together. A cut patch whose earlier files each ended with*** End Patchno longer applies the file the cut fell in.
llx 0.5.0
-
LLX_RECORD=<dir>keeps each session's run whole as JSON lines: every call and its whole output as the model read it, before any elision, the model's words, each turn's usage, each elision and the answer, an agent's events named by it. Off by default; for reading a session again (what an elision took, what the agent read again after one). -
The prompt cache breaks less often in a long task: a pass of the history now elides down to 40% of llx's ceiling instead of 60%, so one cache miss buys about twice as many turns. Each pass rewrites what follows it in the cache (about $0.41 on
claude-sonnet-5-5at 170k tokens), and paid itself back only after some 55 requests; modelled on a task that grows 1k to 3k tokens a request, the deeper pass makes 40% fewer breaks and costs 20% to 26% less, its requests being smaller too (22 breaks instead of 26 in the 300-turn simulation of the tests, whose turns are large for its ceiling). What goes is old outputs, each with a pointer to get it back. -
llx spend [ID]: what a session spent, without reading its file. By task, by agent and by model: requests, input, the share read from the prompt cache, what was written to it, output and money; then the prompt cache's misses, each with its likely cause (the context elided, a change of model, a pause past the cache's five minutes, a new conversation) and what they cost together, and the dearest requests./usagein a session ends with the same report of its earlier tasks. A session's file now keeps, for each model turn, the agent whose turn it is and the model that answered, the tokens written to the cache, and each elision as a step: before, an agent's turns were the main session's steps with no name (its own file had none), so a session's total held its agents' but no one could tell them apart. -
A miss of the prompt cache is noted as it happens:
✻ The prompt cache missed (policy): 182k tokens sent uncached, $0.492, after the context was elided, in the lane of the agent it is. An agent's elisions are noted in its lane too; before, they were not shown at all. -
The history no longer elides an output at every request ("The context neared the model's limit; elided to save it: 1 outputs" at each turn), which rewrote the conversation from there and missed the prompt cache each time. Two causes, seen in a session of 380 turns:
- What no stage elides grows in a long task: the model's reasoning, carried back with each turn and counted by the provider (on
gpt-6.1-solabout 0.7 token for each it wrote). Once it passed 60% of the ceiling, a pass could not get there, the gate stayed open, and each request elided the output just past the protected tail. Now a pass that could not reach its target opens again only once the conversation has grown 30% of the ceiling past where it left it, and then elides all that grew at once. - Past llx's ceiling (272k on a window of a million), the tail itself gave way: the model kept its last two outputs and lost the instruction files, at every request ($1.07 and $1.35 requests with nothing read from the cache). The tail now gives way only past the model's own limit.
- After a switch of model (
gpt-6.1-soltoclaude-sonnet-5-5), the estimate counted the sealed reasoning of the other model's turns, which no provider sends to another: a conversation of 200k tokens was taken for more than the ceiling, and every request elided (up to $0.48 a request instead of about $0.04). A conversation now lets go of another model's reasoning as the model changes (it costs no cache: a provider's is its model's).
- What no stage elides grows in a long task: the model's reasoning, carried back with each turn and counted by the provider (on
-
Old turns' reasoning goes first when a long task nears the limit, before any output it read: OpenAI's sealed reasoning items and Anthropic's thinking blocks, which grow with every turn of a task and no stage could elide (on
gpt-6.1-sola task of 218 turns carried about 0.7 token of it for each one written). The newest turns keep theirs, as the APIs need; the words and calls of a turn stay in their order. Hosts over chat completions keep theirs (DeepSeek and Kimi ask for their reasoning back within a task, Gemini for its signatures), as AI SDK'spruneMessagesleaves a call's own data. -
Examples:
deps.yml, a dependency update read: when a pull request changes a manifest or a lockfile (Dependabot's, Renovate's or yours), llx works out which packages move, reads what their new versions changed, searches the code for what that touches and runs the tests, then one comment it updates sayssafe,revieworbreakingwith the lines that need a change. For Dependabot's pull requests the key must also be a Dependabot secret. -
--schema: aresultmade just as an agent answers (or a background command or a monitor ends) waits for that answer, which reaches the model first; before, the data could be taken without it, the answer left unread. -
--schema'sformat: "regex"holds a pattern to the whole of ECMA-262's syntax even where it has what is not checked here: a back-reference to a group the pattern does not have ((?=a)\1,\k<n>with no groupn), or what is invalid after a lookaround, a back-reference or a property ((?=a)(), is invalid; before, the first unchecked part hid it. A long pattern is judged in one pass however many back-references and lookarounds it has, and a lone surrogate at a class range's end ([z-\uD800]) or a group name spelled with an escape or a combining mark stays valid. -
A reply from OpenRouter or another OpenAI-compatible host that carries
"error": nullbeside its completion is the completion; before, it was taken for a failure and asked again. -
A duration from 9,950 to 9,999 ms reads
10s, not10.0s. -
A token count from 999,950 to 999,999 reads
1.0M, inllx spend,/usageand the footer; before, it read1000kor1000.0k. -
--schema'sformat: "regex"checks a valid pattern with no allocation when it holds a lookaround, a back-reference or a\p{...}too, as the schema package promises for valid data (\p{L}155 ns to 65 ns). -
With an OpenAI API key, a reply that fails, is withheld by the content filter or runs past the window names OpenAI; so does a 5xx or a 429 that outlasts its retries (
OpenAI answered 503: …); before, they named ChatGPT, as with a sign-in, or no host at all. -
An agent that calls
agents,askorjobsis told it works withbashandapply_patch; before, the refusal namedgreptoo, a tool llx no longer has. -
The interface has no indent where text is read or copied: an answer starts at the left edge with no bullet and no hanging indent (a long line wraps flush), a quiet line from llx (a note, a table, the footer under the prompt, a list's
↑ 3 more) too, and the list of sessions, agents and commands under the prompt has no pointer column: only the row the keys are on has its❯. What you typed keeps its❯, and a call keeps its bullet and its└steps.
llx 0.4.0
--schemachecks the whole of JSON Schema, drafts 4 to 2020-12 as the schema's$schemasays: bounds (multipleOfexact in decimal, integers exact past 2^53), lengths in characters,uniqueItems,contains,additionalProperties,patternProperties,propertyNames,const,anyOf/oneOf/allOf/not,if/then/else,dependentRequiredanddependentSchemas,unevaluatedPropertiesandunevaluatedItems,$refwith$idand$anchor;formatheld to (dates and times,email,uri,uuid, addresses and the rest butidn-*), andpatternas ECMA-262 reads it. Before, onlytype,required,properties,itemsandenumwere, and data that broke a bound, added a field or had a wrong date was taken. Each message names the field, the rule and what the data has (data.issues[0].line must be >= 1 (is 0)). What is not checked (a lookaround in a pattern,idn-*, a$refto a document not given) is named on stderr. The checker is its own package (packages/schema, about 230 KB of the binary where thejsonschemacrate would add 1.9 MB): it passes every test it runs of the official JSON-Schema-Test-Suite, agrees with the labels of 36,990 LLM answers to real schemas (MaskBench) on 99.98% (jsonschema99.95%), and is faster thanjsonschemaon every case of its README. A$reffollowed into deep data (a tree a hundred levels down) is no longer cut at 32 levels.- Anthropic's models are called over its own Messages API, with the prompt cache marked: a session on
claude-sonnet-5-5paid its whole conversation again at every turn (0 tokens read from the cache, about $0.33 a turn at 150k tokens of context, $2.94 in two minutes), as Anthropic's OpenAI-compatible endpoint caches no prompt and ignores the reasoning level. Now the system prompt and the tools, the context, and the conversation up to the last turn are read from the cache, the level goes out as the model's effort (a budget of thinking tokens for the older models), and the model's signed thinking goes back with its turn. Any provider of the catalog whose model is served overmessagesis called so; a reply is streamed, so a patch the output limit cut off keeps its whole files (B7). - What a request writes to a prompt cache is priced at the catalog's cache-write price (Anthropic's is 1.25 times the input's):
--budgetand the spend no longer count it as plain input. - A session has no time limit by default: a task you watch is stopped by you, not cut off after 30 minutes.
llx execkeeps 1800 seconds;--timeoutsets one for either. A request the time limit cuts off now ends the task as out of time (exit 2, the limit named) instead of an error of the provider's with no answer (exit 3). - A follow-up task no longer rewrites the start of the conversation at its first request: the history's gate measured it as if nothing were known of how the model counts tokens, and an estimate that ran high (a model's sealed reasoning) elided older outputs the prompt cache held, so the task began with a full cache miss. The measure is kept from task to task.
apply_patchnames every file whose lines it did not find, not only the first, so a patch of many files is mended in one retry; and a long file's nearest lines come with six lines on each side, numbered as a read shows them.- The context says when the project has no
AGENTS.mdorCLAUDE.md, so the model does not search the disk for one (afind ..over a home folder took a minute). - OpenAI with an API key is called over its Responses API, as with a ChatGPT sign-in: over chat completions
gpt-6.1-solandgpt-6-astrarefused every request with tools at a level (400), and no model's reasoning was kept between turns. --schemakeeps the prompt cache to its last request:resultis offered with every request, so the tools at the start of every prompt never change. Its data's request offeredresultalone, and so paid the whole conversation again at every provider. The model may now end the task withresultitself, which saves that request; an answer in words is still followed by it, with the same tools. Aresultbeside other calls is not taken (the work goes on), one made while an agent's answer or a job is still to come waits for it, and aresultthat keeps breaking the schema ends the task without data after two fixes. Over chat completions the call is no longer forced (DeepSeek and Qwen refuse a forced call while they think, Z.ai takes onlyauto, current Claude models refuse one): it is asked for in words, and asked again after an answer in words.- Checked against each provider's documentation:
- Anthropic: the model's thinking goes back in the order it came, a block cut before its signature is dropped, and thinking the API refused as bound to an earlier history is never sent again (it was stripped and resent at every turn after one elision); a refusal (
stop_reason: refusal) or a reply past the window is an error, not an answer;xhighandmaxmay write 64,000 tokens; the older models think between their tool calls (the interleaved-thinking beta); only Anthropic's own models take the Messages API. - A rate limit is waited out as long as the API's
Retry-Afterasks, never past the deadline, at Anthropic, OpenRouter and every chat-completions host; a wait past a minute is said at once, and no pause between attempts grows past a minute. OpenRouter's 402 with a wait (its in-flight budget) is waited out. - Z.ai, Kimi K2.x and DeepSeek are turned off with
thinking.type, Qwen at DashScope withenable_thinking, as their docs say, where a model names nononelevel:reasoning_effort: "none"was ignored or refused there. - OpenRouter: Gemini is no longer marked for the cache (it caches on its own, and OpenRouter bills each mark as a write); signed reasoning parts with no index are kept apart, not joined into one corrupt value; a reply on the person's own provider key (BYOK) costs what that provider charged too;
xhighandmaxmay write 64,000 tokens, as OpenRouter gives a budgeted model's thinking 95% of the limit there. - ChatGPT: a reply that failed for load before any word of it (
server_is_overloaded, a rate limit of a moment) is asked again, as Codex does; one past the window says so. - Chat completions: a Gemini call's thought signature goes back on the call (Gemini refuses the next request without it), an answer given in chunks (Mistral's reasoning models) is read and goes back whole, a reply the host's filter withheld is an error, and a host that counts cached tokens at the top of its usage (Together) is read; a 403 (a permission or a moderation flag) no longer says the key was refused; OpenRouter's
~vendor/…-latestaliases are marked for the cache as their vendor's models are.
- Anthropic: the model's thinking goes back in the order it came, a block cut before its signature is dropped, and thinking the API refused as bound to an earlier history is never sent again (it was stripped and resent at every turn after one elision); a refusal (
- A command moved to the background tells the model not to change or check the files it writes until it ends: a formatter still running rewrote files the model was patching.
llx 0.3.0
-
The project is now
llx-cli: the repository isrsaryev/llx-cli(the actionuses: rsaryev/llx-cli@v0, the skillnpx skills add rsaryev/llx-cli, the imageghcr.io/rsaryev/llx-cli), and the binary's package isllx-cli(cargo install --locked --git https://github.com/rsaryev/llx-cli llx-cli). The command is stillllx, inside the release's archives too, nowllx-cli-<target>.tar.gz. GitHub redirects the old name. -
A monitor waits for one thing, as Localix's does: its command is a check run every
everyseconds (10 by default, at least 5) until it exits 0 or its time is up, and the agent is told once how it ended (met after 4 checks (32 s),timed out after …,could not run: Exit code: 127) with what the last check printed. It no longer hands the agent each line a command prints: a monitor printing every second kept a task going for 22 turns in 32 s. In the list a monitor shows its checks (≋ ready … 3 checks · 4m 28s left), opens with Enter to what its last check printed, and stays listed with how it ended, as a command in the background does. -
A job the agent stops says nothing more of it; one the person stops (
x) opens no task of its own, and the agent reads it with the person's next task. -
The list under the composer ends each row's time and tokens, or how a command in the background runs or ended, at the right edge, where the footer's spend ends: the rows read as one table, what a row does cut first when the room runs out.
-
A resized window draws the session again at its new width: the terminal reflows what it shows, so the live area was erased short and its copies (the composer's rules) stayed on the screen. Each block of the transcript is drawn again at the width, not cut.
-
A command in the background reads as running, not failed:
Running in the background, orMoved to the background after 120.0 sunder what it printed so far, never the red lines meant for the model. -
Enter on a command in the background shows what it prints, as it prints (asked of the server each second while open,
Command::JobOutput), with how it runs;xstops it, Esc goes back. One that ended stays listed with how it ended, red when it failed or was stopped (✗), untilxremoves it; the footer counts only those that run. A monitor's and a schedule's rows offerx stopalone. -
A task that something from the background opened (a command's end, a monitor's lines, a schedule) starts in the session's history as where it came from (
$ tests · Exit code: 1,≋ ticks · tick 1,◷ nightly · …), as a saved session shows it, not as the tagged message the model reads. -
The advice that reviews an answer reads what came in during the task (a background command's end, a monitor's lines, an agent's answer, the person's words) in its place among the calls: an answer that reported a command's exit code from its
<background>message was sent back twice as unfinished, the review seeing only that the command was started. -
A long command goes on in the background, as Claude Code's do:
bashwaits for a command 120 s at most (or itstimeout_ms, if less), and one still running then becomes a job ofjobsinstead of being killed: the model reads what it printed so far and the file its whole output goes to, and its end comes back once as a<background>message (a task of its own when none runs).run_in_background: truestarts one there at once, named bydescription. It is listed and stopped as a job (jobs list,jobs stop,xon its row; the footer counts2 shells, 1 monitor), runs at most 30 minutes (10 inexec, whose task waits for it), and ends with the session; asleepis killed at its wait. Before, a test run that hung held the task until itstimeout_ms(a benchmark lost 12 minutes to two), and the timeout's message asked the model to raise it. An agent's commands are still killed at theirtimeout_ms. -
What the session could not do with something sent from the terminal (words typed for a session that had just ended, closing one already gone) is shown as an error: it was dropped without a word.
-
A session is open in one
llxat a time: anotherllxthat resumes it while it is open (llx resume <id>,-c, the list's row) is refused,session <id> is open in another llx: quit it there first, and its file is left as it was. Before, two terminals on one session each rewrote its file whole, so the tasks of the one that saved first were lost, and two saves at once could leave the file cut short. The lock is the operating system's: a process that crashes or is killed lets it go. -
Sessions are JSON Lines (
~/.llx/sessions/<id>.jsonl): the session's header, then each task as it ends and its title, appended, never rewritten whole; a line a crash cut short is left out when read. Sessions saved as.jsonby an earlier llx are no longer read. -
Building llx from source needs Rust 1.89 or later (the standard library's file locks).
-
The daemon is gone (
llx serve,--no-daemon,LLX_NO_DAEMON): a session at the terminal runs in thellxthat shows it, with its agents and jobs, and ends with it;llx resumeandllx -cgo on with it from its file. "Move to background and exit" is no longer offered,llx serve statusandstopare gone, and no socket is left in$TMPDIR/llx-<uid>/. A session ran no faster in the daemon (0.2 ms more to start, nothing per event), and it cost code and bugs.exec,decideand the GitHub Action never used it. -
SIGTERM or SIGHUP at the prompt gives the terminal back as it ends the process: a session run in process (
--no-daemon, and now every session) left the terminal raw. -
The binary no longer carries Mozilla's root certificates, which it never read: TLS verifies with the system's trust store, as before (
RootCerts::PlatformVerifier). 132 KB less (2.76 MB on macOS). -
The skill describes llx instead of sending the agent to its help first: what each part is for, with examples to run as they are (a pull-request review workflow for the action, a gate, helpers in parallel,
llx decide, and a search of the code by what it does asrgandllx decidemake it), and at its endllx exec --helpandllx decide --helpas the release prints them (scripts/skill-helpwrites them, a test checks them). In Claude Code the skill asks once before it is used, as it grants commands;Skill(llx:llx)allows it where no one can answer. -
An answer given while background agents still worked, then stopped while it waited for them, read twice in the session: once as the words said as the wait began, once more as the task's answer. It is shown once; stdout,
-oand--jsonhave it as before. -
In a read-only mode (
plan) the context says when to ask the person withask, as the other modes do at a terminal: it was left out, so a plan's open questions were guessed. -
scripts/ci-dockerruns CI's jobs asrunner, a user with passwordless sudo, as GitHub's runners do: as root, the action's lockdown tested for real could never drop its privileges, and theactionjob failed. Its volumes are new (llx-ci-runner-*); the oldllx-ci-*ones can be removed. -
A session's end reaches the interface after the last word of its monitors: a monitor still running as the session closed told its jobs after the end, and a client attaching later was handed them as the state of a session gone.
-
The skill, for any agent:
skills/llx/SKILL.md, a discovery stub as agent-browser's is, installed withnpx skills add rsaryev/llx(Claude Code, Codex, Cursor, Gemini CLI, OpenCode and others) or in Claude Code as the plugin (/plugin install llx --marketplace rsaryev/llx). It describes all of llx and when each part pays (the coding agent, one task in a script or CI and the GitHub Action, helpers on another model,llx decide, the modes and the sandbox), lets Claude Code run without asking, while the skill is active,llx decideandllx exec --mode planwith any arguments after them,llx doctor,llx --helpandllx exec --help(itsallowed-tools: nothing else; every other command goes by the person's permission settings), and points at each command's--help, which is the guide now (a paragraph for an agent inllx execandllx decide --help), so it never goes stale. The Claude Code plugin's subagent, its session hook and its settings, and the Codex lines, are gone: the skill replaces them, and llx reads its key and model from/loginas anywhere. -
llx decide QUESTION FILE…asks about each file on its own, eight at once, and prints a line each (CHOICE<TAB>FILE, or with--jsonan object with itsfile) in the order given: one command for a directory, where a shell loop would not fit an agent's allow rule. With--expect, it exits 1 when any file's pick differs; a file that cannot be read or answered is named on stderr and ends the run with 3. -
llx decide --checkexits 0 when decide can run (an OpenRouter key is set or saved) and 3 when it cannot, asking no model. -
An
--allowrule no longer lets a command write a file through>&followed by a word that is not a descriptor (echo hi >&2xwrites the file2x): such a line is asked, as any other redirect to a file. -
A question withdrawn as it was asked (the lane closed, the person left) is no longer shown again to every interface that attaches later.
-
An entry the session took as it was sent no longer stays shown as waiting under the composer: the queue reaches the interface in the order it changed.
-
The cursor no longer lands a row too low when rows wider than the terminal sit both above and below it in the live area.
-
A task stopped by
--timeoutor--budgetno longer reads "out of turns" in the session list, the tree under the composer and the line a lane is told: it reads "limit reached", as one out of turns does, the error line under it saying which. -
In a choice shown in tabs (
/model's providers), a number picks only a row o...
llx 0.2.0
The first public release.
llx exec: one task, then exit, with an exit code a pipeline branches on (0done,1no data,2exhausted,3error,130interrupted),--jsonevents ending withrun.completed, and with--schemathe answer as data matching a JSON Schema. A task is bounded by--max-turns,--timeoutand--budget.llx: a minimal agent at the terminal, over five tools (bash,apply_patch,ask,agents,jobs). Every run is a session (llx -c,llx sessions,llx resume), several at once beside each other, kept by a daemon when the terminal leaves.- Modes:
defaultruns commands in the system's sandbox (Seatbelt on macOS, Landlock and seccomp on Linux), which writes only inside the workspace and opens no network, and asks before anything that reaches further;planis read-only;bypass(-y) allows everything;--allowand--denyrules, and modes of your own insettings.json. - Models: 1,000+ models from 200+ providers, from models.dev's catalog: a ChatGPT sign-in, OpenRouter, or a provider's key. With an OpenRouter key, a decision model picks each conversation's reasoning level and takes a second look at an answer that may leave work undone (
--no-adviceturns it off).llx decideasks it about stdin and prints the option it picked. - The GitHub Action
rsaryev/llx@v0(llx agent): installs the release, runsllx execonce and hands back the answer, the exit code and the spend. On a hosted Linux runner it dropssudoand the runner's groups for llx and its commands, redacts the step's secrets from what it hands back, and can read the instruction files of a trusted revision (instructions-from). Ready-made workflows inexamples/: pull request review,@llxin a comment, triage, a failed run explained, a described pull request, a draft release, a daily gate, a weekly audit, a Jira work item made a draft pull request, and breaking changes to an HTTP API. - Install:
curl -fsSL https://llx.sh/install | shon macOS (Apple silicon and Intel) and Linux (x86_64 and arm64), checked against the release'sSHA256SUMS, each archive attested; alsomise use -g github:rsaryev/llx,cargo binstall --git https://github.com/rsaryev/llx llx,cargo install, and the imageghcr.io/rsaryev/llx:0.2.0.