Skip to content

Releases

llx 0.6.2

Choose a tag to compare

@github-actions github-actions released this 17 Nov 20:03
2ccfc6b
  • Update llx with llx --update after 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. Set LLX_UPDATE_CHECK=0 to 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.

  • --schema is 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

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:02
52fd3fe
  • The project is Localix CLI, and its repository is localixai/localix-cli. The command stays
    llx. A release's archives are localix-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 is localixai/localix-cli@v0 (rsaryev/llx-cli@v0 forwards to it), and the image of
    a release is ghcr.io/localixai/localix-cli:<version>.
  • curl -fsSL https://llx.sh/install | sh installs 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], then llx decide asked 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 git pre-commit hook and a CI job, each run for real.

llx 0.6.0

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
00febd3
  • 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, exec at 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 --json is 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 of pulldown-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. In exec, 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 — Author names 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.ts or title="…") is drawn under the name, a diff or patch fence in green and red by what its lines add and take away, a ```tree fence as a file tree with its branches, what is said of the names in one column; a mermaid fence says it is a diagram. A formula ($x^2$, $$ … $$, a math fence) is written as the Unicode a terminal has, \frac{1}{k} \sum_{i=1}^{k} r_i as 1/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's llama-server (8080), and any you name under local in ~/.config/llx/settings.json ({"name": "box", "url": "http://box.lan:8080"}). /model lists those that answer under Local:, beside the catalog's providers under Cloud: (Local: none running when none does); --provider ollama -m qwen3:8b names one for a run; llx doctor says 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=0 looks only for what the settings name. Any other OpenAI-compatible host, wherever it is, goes under hosts ({"name": "work", "url": "https://llm.example/v1", "key": "…"}, with models, context and output for what it does not say itself): a Hosts: tab of /model and --provider work, called as any plain host with none of a local server's limits. /login adds a host too: its last row, Another host, asks the address, a name and the key, checks that it answers and saves it in settings.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 as max_completion_tokens where 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

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
0e8b0b5
  • 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 with privileges: 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 for plan. /mode and the modes /mode offers 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, without M stats.py between them.
  • The exec trace reads a call from the project, as the session does: a command's own cd into 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 cd into the project, no absolute path; before, the row was cut before the command itself.
  • A model switch names the settings file from ~, as /status does.
  • /status writes the workspace and the key's file from ~, and /usage shows 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 cut apply_patch arrived 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_patch reads a patch ended after each file as one patch: a *** End Patch between 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_patch takes its text whatever else the model wrote beside it where it is offered as a function: a call with a description next 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 File followed by an *** Add File of 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 Patch no longer applies the file the cut fell in.

llx 0.5.0

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
09b4b92
  • 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-5 at 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. /usage in 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-sol about 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-sol to claude-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).
  • 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-sol a 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's pruneMessages leaves 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 says safe, review or breaking with the lines that need a change. For Dependabot's pull requests the key must also be a Dependabot secret.

  • --schema: a result made 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's format: "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 group n), 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": null beside 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, not 10.0s.

  • A token count from 999,950 to 999,999 reads 1.0M, in llx spend, /usage and the footer; before, it read 1000k or 1000.0k.

  • --schema's format: "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, ask or jobs is told it works with bash and apply_patch; before, the refusal named grep too, 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

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
1ca733e
  • --schema checks the whole of JSON Schema, drafts 4 to 2020-12 as the schema's $schema says: bounds (multipleOf exact in decimal, integers exact past 2^53), lengths in characters, uniqueItems, contains, additionalProperties, patternProperties, propertyNames, const, anyOf/oneOf/allOf/not, if/then/else, dependentRequired and dependentSchemas, unevaluatedProperties and unevaluatedItems, $ref with $id and $anchor; format held to (dates and times, email, uri, uuid, addresses and the rest but idn-*), and pattern as ECMA-262 reads it. Before, only type, required, properties, items and enum were, 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 $ref to a document not given) is named on stderr. The checker is its own package (packages/schema, about 230 KB of the binary where the jsonschema crate 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% (jsonschema 99.95%), and is faster than jsonschema on every case of its README. A $ref followed 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-5 paid 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 over messages is 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): --budget and 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 exec keeps 1800 seconds; --timeout sets 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_patch names 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.md or CLAUDE.md, so the model does not search the disk for one (a find .. 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-sol and gpt-6-astra refused every request with tools at a level (400), and no model's reasoning was kept between turns.
  • --schema keeps the prompt cache to its last request: result is offered with every request, so the tools at the start of every prompt never change. Its data's request offered result alone, and so paid the whole conversation again at every provider. The model may now end the task with result itself, which saves that request; an answer in words is still followed by it, with the same tools. A result beside 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 a result that 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 only auto, 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; xhigh and max may 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-After asks, 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 with enable_thinking, as their docs say, where a model names no none level: 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; xhigh and max may 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/…-latest aliases are marked for the cache as their vendor's models are.
  • 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

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
5804345
  • The project is now llx-cli: the repository is rsaryev/llx-cli (the action uses: rsaryev/llx-cli@v0, the skill npx skills add rsaryev/llx-cli, the image ghcr.io/rsaryev/llx-cli), and the binary's package is llx-cli (cargo install --locked --git https://github.com/rsaryev/llx-cli llx-cli). The command is still llx, inside the release's archives too, now llx-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 every seconds (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, or Moved to the background after 120.0 s under 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; x stops it, Esc goes back. One that ended stays listed with how it ended, red when it failed or was stopped (✗), until x removes it; the footer counts only those that run. A monitor's and a schedule's rows offer x stop alone.

  • 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: bash waits for a command 120 s at most (or its timeout_ms, if less), and one still running then becomes a job of jobs instead 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: true starts one there at once, named by description. It is listed and stopped as a job (jobs list, jobs stop, x on its row; the footer counts 2 shells, 1 monitor), runs at most 30 minutes (10 in exec, whose task waits for it), and ends with the session; a sleep is killed at its wait. Before, a test run that hung held the task until its timeout_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 their timeout_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 llx at a time: another llx that 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 .json by 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 the llx that shows it, with its agents and jobs, and ends with it; llx resume and llx -c go on with it from its file. "Move to background and exit" is no longer offered, llx serve status and stop are 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, decide and 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 as rg and llx decide make it), and at its end llx exec --help and llx decide --help as the release prints them (scripts/skill-help writes 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, -o and --json have it as before.

  • In a read-only mode (plan) the context says when to ask the person with ask, as the other modes do at a terminal: it was left out, so a plan's open questions were guessed.

  • scripts/ci-docker runs CI's jobs as runner, 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 the action job failed. Its volumes are new (llx-ci-runner-*); the old llx-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 with npx 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 decide and llx exec --mode plan with any arguments after them, llx doctor, llx --help and llx exec --help (its allowed-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 in llx exec and llx 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 /login as 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 --json an object with its file) 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 --check exits 0 when decide can run (an OpenRouter key is set or saved) and 3 when it cannot, asking no model.

  • An --allow rule no longer lets a command write a file through >& followed by a word that is not a descriptor (echo hi >&2x writes the file 2x): 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 --timeout or --budget no 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...

Read more

llx 0.2.0

Choose a tag to compare

@rsaryev rsaryev released this 17 Nov 11:01
6a0d1af

The first public release.

  • llx exec: one task, then exit, with an exit code a pipeline branches on (0 done, 1 no data, 2 exhausted, 3 error, 130 interrupted), --json events ending with run.completed, and with --schema the answer as data matching a JSON Schema. A task is bounded by --max-turns, --timeout and --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: default runs 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; plan is read-only; bypass (-y) allows everything; --allow and --deny rules, and modes of your own in settings.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-advice turns it off). llx decide asks it about stdin and prints the option it picked.
  • The GitHub Action rsaryev/llx@v0 (llx agent): installs the release, runs llx exec once and hands back the answer, the exit code and the spend. On a hosted Linux runner it drops sudo and 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 in examples/: pull request review, @llx in 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 | sh on macOS (Apple silicon and Intel) and Linux (x86_64 and arm64), checked against the release's SHA256SUMS, each archive attested; also mise use -g github:rsaryev/llx, cargo binstall --git https://github.com/rsaryev/llx llx, cargo install, and the image ghcr.io/rsaryev/llx:0.2.0.