<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Christophe Le Bars</title>
    <description>The latest articles on DEV Community by Christophe Le Bars (@clbrge).</description>
    <link>https://dev.to/clbrge</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F1821828%2F527fc536-d559-4503-889a-bd1c6740e240.jpeg</url>
      <title>DEV Community: Christophe Le Bars</title>
      <link>https://dev.to/clbrge</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/clbrge"/>
    <language>en</language>
    <item>
      <title>A coding agent you can leave and return to: trying spore here</title>
      <dc:creator>Christophe Le Bars</dc:creator>
      <pubDate>Sun, 08 Nov 2026 14:59:39 +0000</pubDate>
      <link>https://dev.to/clbrge/a-coding-agent-you-can-leave-and-return-to-trying-spore-here-1j3d</link>
      <guid>https://dev.to/clbrge/a-coding-agent-you-can-leave-and-return-to-trying-spore-here-1j3d</guid>
      <description>&lt;p&gt;&lt;em&gt;Run a bounded coding task in a Git project, inspect its changes, and return to the same agent without treating the conversation as the only artifact.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;In the &lt;a href="https://dev.to/clbrge/an-ai-agent-built-a-godot-game-then-is-checking-its-work-3n2d"&gt;first article&lt;/a&gt;, a Spore agent built a Godot game, wrote bots to test it and revised it after a second prompt.&lt;/p&gt;

&lt;p&gt;You don't need a game-sized task to try the same runtime. &lt;code&gt;spore here&lt;/code&gt; opens a coding agent in a Git repository. It works on the files in place, runs commands and returns to the same conversation when you reopen it.&lt;/p&gt;

&lt;p&gt;This article is a small, documented first-use workflow—not another recorded experiment. The suggested task below is yours to run; it isn't a claim that every model will complete it correctly.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;I'm the creator of &lt;a href="https://github.com/RHIZOGRIP/spore" rel="noopener noreferrer"&gt;Spore&lt;/a&gt;, an Apache-2.0 runtime for persistent AI agents.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Start with a small project, not your most sensitive repository
&lt;/h2&gt;

&lt;p&gt;Use a disposable clone of a project you understand, ideally one with a working test command. Start with a clean working tree so changes are easy to attribute.&lt;/p&gt;

&lt;p&gt;Don't include credentials, confidential documents or production configuration in this first experiment. The agent has network access by default. Confinement doesn't prevent it from sending material it is allowed to read.&lt;/p&gt;

&lt;p&gt;The agent can read and change the project you grant it. That's the point of the workflow, but also a reason to choose the project deliberately.&lt;/p&gt;

&lt;h2&gt;
  
  
  Set up the runtime
&lt;/h2&gt;

&lt;p&gt;Agents execute on Linux, x64 or arm64. Current requirements include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Node 24+ with bundled SQLite 3.51.3 or newer;&lt;/li&gt;
&lt;li&gt;Linux 5.13+ with Landlock enabled; 6.12+ is recommended for additional isolation features;&lt;/li&gt;
&lt;li&gt;unprivileged user namespaces;&lt;/li&gt;
&lt;li&gt;supported model access.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On macOS, setup uses a Lima Linux VM. On Windows, run the Linux workflow in WSL2. The &lt;a href="https://rhizogrip.com/spore/install" rel="noopener noreferrer"&gt;installation guide&lt;/a&gt; covers platform-specific steps; don't assume each host has identical confinement features.&lt;/p&gt;

&lt;p&gt;For Bash on a supported Linux host, or inside WSL2 with the prerequisites installed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="nv"&gt;$HOME&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;
npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; @rhizogrip/spore-cli
spore setup
spore doctor
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The install line changes the global npm installation. Setup writes configuration and connects model access; subsequent agent work may incur provider charges or consume subscription allowances.&lt;/p&gt;

&lt;p&gt;Setup offers recommended models passing Spore's core and identity conformance tiers. That's more useful than selecting a model solely because it appears in a provider's catalog, but it isn't a guarantee that a model will solve your task or that your account can access it.&lt;/p&gt;

&lt;p&gt;On Ubuntu, namespace restrictions may require an AppArmor adjustment. Read the specific instructions setup prints rather than disabling host restrictions indiscriminately. &lt;code&gt;spore doctor&lt;/code&gt; reports host prerequisites and exercises boundaries; treat warnings as information to resolve, not decoration to dismiss.&lt;/p&gt;

&lt;h2&gt;
  
  
  Open the project
&lt;/h2&gt;

&lt;p&gt;In a terminal already opened at the root of your disposable Git clone, run &lt;code&gt;spore here&lt;/code&gt;. The first time, choose the &lt;strong&gt;code&lt;/strong&gt; preset.&lt;/p&gt;

&lt;p&gt;The terminal interface opens. The agent can read the project, edit its files and run its tests. It isn't editing a separate copy that later gets silently merged into your branch: you and the agent share the working directory.&lt;/p&gt;

&lt;p&gt;A useful first task is one small behavior change with a precise acceptance condition. For example, in a project that has pagination:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Find the function that parses the page number from a query parameter.

Implement this behavior:
- A missing value returns page 1.
- A string containing only decimal digits is accepted if its numeric value
  is a positive safe integer.
- Empty strings, whitespace, signs, decimals, mixed text, zero, and values
  outside the safe-integer range are rejected using the project's existing
  error convention.

Add tests for those cases. Run the relevant tests and report the commands
and results. Keep the change small: no new dependencies or unrelated refactors.

If the project has no pagination parser, tell me rather than inventing one.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is intentionally narrower than “improve validation.” You know what to inspect, and the agent has an explicit way to report that the task doesn't fit the repository.&lt;/p&gt;

&lt;p&gt;The instruction isn't a security policy. It tells the model what work you want; access and execution limits belong to the runtime and configuration.&lt;/p&gt;

&lt;h2&gt;
  
  
  Inspect the changes before asking for more
&lt;/h2&gt;

&lt;p&gt;After the agent answers, use this command &lt;strong&gt;inside Spore's terminal interface&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/diff
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This opens the changes since the current session began in Git's pager.&lt;/p&gt;

&lt;p&gt;Read the actual implementation and tests. Does the parser accidentally accept a numeric prefix? Does it reject unsafe integers? Do the tests exercise the behavior, rather than just repeat the implementation's assumptions?&lt;/p&gt;

&lt;p&gt;Run the project's tests yourself as well. An agent's report that tests passed is not a substitute for inspecting the command and its output.&lt;/p&gt;

&lt;h3&gt;
  
  
  What the snapshot does—and doesn't—mean
&lt;/h3&gt;

&lt;p&gt;Spore makes a snapshot when the session opens, including untracked files, under its own Git ref. Your branch and staging area aren't moved by that snapshot.&lt;/p&gt;

&lt;p&gt;Because the working directory is shared, &lt;code&gt;/diff&lt;/code&gt; includes &lt;strong&gt;your edits too&lt;/strong&gt;, not only the agent's. Ignored files are left alone by the snapshot/undo workflow.&lt;/p&gt;

&lt;p&gt;Don't confuse a session snapshot with a commit, a backup of every file, or an audit that attributes each line to a particular author.&lt;/p&gt;

&lt;h2&gt;
  
  
  Leave, then return
&lt;/h2&gt;

&lt;p&gt;Once the task has finished, close the terminal interface. Later, open a terminal in the same repository and run &lt;code&gt;spore here&lt;/code&gt; again.&lt;/p&gt;

&lt;p&gt;You return to the same spore and conversation. Its workspace still holds the programs and files it made; closing the screen hasn't turned that work into an expired chat session.&lt;/p&gt;

&lt;p&gt;A follow-up could be:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Review the pagination change against the acceptance conditions from the
previous task. Inspect the current files and rerun the relevant tests.
Don't assume the repository is unchanged. Report any mismatch before editing.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Persistence is not omniscience. You or another tool may have changed the project. The useful behavior is to inspect the current state and reuse relevant artifacts—not blindly trust a previous answer.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;There is also a new session snapshot.&lt;/strong&gt; After reopening, &lt;code&gt;/diff&lt;/code&gt; compares against that new baseline. It doesn't automatically show the entire previous session's work. Use ordinary Git history and diffs for longer-term comparisons.&lt;/p&gt;

&lt;h2&gt;
  
  
  Undo is a deliberate operation
&lt;/h2&gt;

&lt;p&gt;Inside the interface:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/undo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Spore shows what restoring the session snapshot would change. Review that before proceeding.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Accepting the restore discards changes since this session opened, including your own changes in the snapshotted files.&lt;/strong&gt; It isn't “undo only what the AI did.” Ignored files remain outside that mechanism.&lt;/p&gt;

&lt;p&gt;This is why a disposable clone and a small task make a better first experiment than a busy working tree. Commit work you want to retain using your normal Git workflow.&lt;/p&gt;

&lt;h2&gt;
  
  
  Fewer built-in tools, not fewer possible tasks
&lt;/h2&gt;

&lt;p&gt;Spore exposes seven built-in tools. It doesn't need a different model-facing tool for every file search, parser or service integration: ordinary programs provide those capabilities.&lt;/p&gt;

&lt;p&gt;The related design choice is to keep useful procedures as programs. If a task repeats, the agent can write and test a helper, then run it again instead of reconstructing the procedure through another model response.&lt;/p&gt;

&lt;p&gt;Large command outputs stay in files. The agent can search and read relevant pieces rather than automatically carrying the entire output into context.&lt;/p&gt;

&lt;p&gt;These are design choices and guidance, not a guarantee that the model always chooses an efficient approach. Inspect the work and its records.&lt;/p&gt;

&lt;h2&gt;
  
  
  What stays outside the agent's control
&lt;/h2&gt;

&lt;p&gt;The kernel enforces filesystem access boundaries. Provider and configured source credentials are held outside the agent, rather than handed to its programs. The runtime records activity and spend where the agent cannot rewrite them.&lt;/p&gt;

&lt;p&gt;Time, spend and model-call limits apply per turn. Soft limits ask it to wrap up; hard limits stop further work according to the runtime's rules. An already-running model call can finish and add cost beyond the spend threshold. Aggregate budgeting across agents remains an operator responsibility.&lt;/p&gt;

&lt;p&gt;Two boundaries matter when trying this in a project:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Credentials held by a broker are different from secrets you leave in readable project files.&lt;/li&gt;
&lt;li&gt;Kernel confinement is different from network isolation. Additional egress policy belongs to the host.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The &lt;a href="https://rhizogrip.com/spore/security" rel="noopener noreferrer"&gt;security explanation&lt;/a&gt; describes the trust boundary and its limitations.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to look for in your first session
&lt;/h2&gt;

&lt;p&gt;Don't judge only whether the final answer sounds plausible. Check:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Was the requested change actually made?&lt;/li&gt;
&lt;li&gt;Were the specified cases tested?&lt;/li&gt;
&lt;li&gt;Did the agent stay within scope?&lt;/li&gt;
&lt;li&gt;Can you inspect its work and return to it later?&lt;/li&gt;
&lt;li&gt;Are you comfortable with the files and capabilities you granted it?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That's the small experiment: a familiar coding workflow, persistent artifacts and boundaries you can examine.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://rhizogrip.com/spore/install" rel="noopener noreferrer"&gt;Install Spore&lt;/a&gt;&lt;/strong&gt; · &lt;strong&gt;&lt;a href="https://github.com/RHIZOGRIP/spore" rel="noopener noreferrer"&gt;Source&lt;/a&gt;&lt;/strong&gt; · &lt;strong&gt;&lt;a href="https://discord.gg/wzeQc3VgE" rel="noopener noreferrer"&gt;Community&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;If you try it, I'd be interested in the task, your host setup and where the workflow gets in your way—not just whether the first answer looked good.&lt;/p&gt;

&lt;p&gt;The next article will move from the terminal to an application: submitting work through Node or HTTP and reconnecting to the result.&lt;/p&gt;

</description>
      <category>agentaichallenge</category>
      <category>ai</category>
      <category>node</category>
      <category>programming</category>
    </item>
    <item>
      <title>An AI agent built a Godot game. Then it checked its work.</title>
      <dc:creator>Christophe Le Bars</dc:creator>
      <pubDate>Sat, 07 Nov 2026 12:51:19 +0000</pubDate>
      <link>https://dev.to/clbrge/an-ai-agent-built-a-godot-game-then-is-checking-its-work-3n2d</link>
      <guid>https://dev.to/clbrge/an-ai-agent-built-a-godot-game-then-is-checking-its-work-3n2d</guid>
      <description>&lt;p&gt;An agent built a game, wrote bots to play it, and adjusted the game from their results. It passed every target in the first prompt.&lt;/p&gt;

&lt;p&gt;That wasn't the end of the experiment. The results exposed questions those targets hadn't asked: could every seed be won? Was judging a bargain actually better than accepting every offer? Could the player even see the ending?&lt;/p&gt;

&lt;p&gt;A second prompt sent the agent back. Nobody edited the game by hand between the two turns.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foo933u19i91b9ov79m56.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Foo933u19i91b9ov79m56.jpg" alt=" " width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;You can &lt;a href="https://play.rhizogrip.com/keris/index.html" rel="noopener noreferrer"&gt;play the result in your browser&lt;/a&gt;, or inspect the &lt;a href="https://github.com/RHIZOGRIP/spore-demos/tree/main/godot/keris" rel="noopener noreferrer"&gt;prompts, source, results and checks&lt;/a&gt;.&lt;/strong&gt; This is one recorded example, not a benchmark or a promise that another run will succeed.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;This is the first article in Building with persistent AI agents. I'm the author of &lt;a href="https://github.com/RHIZOGRIP/spore" rel="noopener noreferrer"&gt;Spore&lt;/a&gt;, the open-source runtime used for this experiment.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The task: keep a doomed city above water
&lt;/h2&gt;

&lt;p&gt;Kêr-Is draws on the Breton legend of Ys: a city below sea level, protected by dikes and a bronze sea gate. The gate brings trade. It can also let the sea in.&lt;/p&gt;

&lt;p&gt;The player has to survive twelve tides. Workers quarry stone, grow grain and repair the dike. Gold hires workers. Opening the gate makes money, but the forecast can be wrong. A stranger offers resources in exchange for damage that only appears later.&lt;/p&gt;

&lt;p&gt;On a loss, the city sinks and its bells keep ringing under the water.&lt;/p&gt;

&lt;p&gt;The prompt specified that structure, the numerical acceptance targets and the execution environment. It was not just “make a game.” It required art and sound generated in code, without downloaded assets, and game rules separated from rendering so automated playtests could run headlessly.&lt;/p&gt;

&lt;p&gt;The agent wrote the code, generated the visuals and sound, chose the balancing numbers, recorded video and exported the game for the web.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why bots were part of the prompt
&lt;/h2&gt;

&lt;p&gt;A screenshot can show that a game exists. It cannot establish that repairing the dike matters, or that one trivial strategy doesn't dominate.&lt;/p&gt;

&lt;p&gt;So the prompt required several kinds of player:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Idle:&lt;/strong&gt; does nothing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Greedy:&lt;/strong&gt; keeps the gate open and accepts every bargain.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fixed:&lt;/strong&gt; keeps the same worker allocation and gate policy throughout. All 110 combinations were tried.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Steward:&lt;/strong&gt; reacts to information a player can see.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Seer:&lt;/strong&gt; has knowledge of future events.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The tests covered 200 seeds. Targets included idle losing early, greedy rarely winning, fixed strategies doing poorly, and steward winning within a specified range. Removing repairs or keeping the gate permanently closed had to make steward substantially worse.&lt;/p&gt;

&lt;p&gt;These were explicit tests of the intended design, not a model's impression that the game felt balanced.&lt;/p&gt;

&lt;p&gt;The agent could run the tests, inspect results, change the implementation and run them again. The &lt;a href="https://github.com/RHIZOGRIP/spore-demos/blob/main/godot/keris/turn-2/attempts.md" rel="noopener noreferrer"&gt;published attempt log&lt;/a&gt; records problems such as trade being unnecessary and flooded districts making defence easier rather than harder.&lt;/p&gt;

&lt;h2&gt;
  
  
  Passing the targets wasn't enough
&lt;/h2&gt;

&lt;p&gt;The first turn met all seven original targets. But reviewing the data revealed three important gaps.&lt;/p&gt;

&lt;h3&gt;
  
  
  A weak oracle doesn't prove an impossible game
&lt;/h3&gt;

&lt;p&gt;None of the tested policies won 24 of the 200 seeds. Seer won 87% overall.&lt;/p&gt;

&lt;p&gt;That did &lt;strong&gt;not&lt;/strong&gt; establish that the remaining seeds were impossible. It could mean the bot wasn't clever enough.&lt;/p&gt;

&lt;p&gt;In the second turn, the agent wrote a search over the full future. It found winning plans for every one of the 200 seeds and replayed them through the game's rules.&lt;/p&gt;

&lt;p&gt;The important distinction is that it improved the search, not simply the win rate by making the game easier. The published comparison reports unchanged balance parameters and identical outcomes for all fixed strategies across the two turns.&lt;/p&gt;

&lt;p&gt;There is still a caveat: a full-future search is no longer the original “plays like steward, but knows the future” bot. It establishes that winning paths exist in these seeds, not that a human could discover them. In the final results, 58 seeds were won by seer alone.&lt;/p&gt;

&lt;h3&gt;
  
  
  The stranger rewarded the wrong behavior
&lt;/h3&gt;

&lt;p&gt;After the first turn, always accepting bargains won 55% of seeds. Steward's selective rule won only 44.5%.&lt;/p&gt;

&lt;p&gt;The original targets required bargains to help some runs and ruin others. That could be true even while accepting every offer was the better strategy.&lt;/p&gt;

&lt;p&gt;The second prompt added a stronger requirement: selective play should beat both always accepting and never accepting.&lt;/p&gt;

&lt;p&gt;The agent gave the stranger a visible voice—warm, wavering or hollow—that hints at the damage behind the gift. Steward could use that information. Its win rate rose to 60%, against 55% for always accepting.&lt;/p&gt;

&lt;p&gt;That meets the new target, but it also exposes another design compromise: the signal is quite revealing. In the later unseen-seed test, heavy damage followed a hollow voice almost every time. Wavering offers retained more uncertainty.&lt;/p&gt;

&lt;p&gt;A passing test isn't the same as an interesting game-design decision.&lt;/p&gt;

&lt;h3&gt;
  
  
  The ending existed, but the player couldn't see it
&lt;/h3&gt;

&lt;p&gt;The result dialog covered the drowned city, and the final scene was too dark.&lt;/p&gt;

&lt;p&gt;The second turn hid planning panels during the sinking, kept the city lit, and delayed the result until the bells had rung for eight seconds.&lt;/p&gt;

&lt;p&gt;The numerical balance tests hadn't asked whether the ending was visible. That needed a different kind of review.&lt;/p&gt;

&lt;h2&gt;
  
  
  We also made a mistake in the prompt
&lt;/h2&gt;

&lt;p&gt;Our draft of the first prompt included a 95% seer target. The actual prompt sent to the agent did not.&lt;/p&gt;

&lt;p&gt;We wrote the second prompt from the draft and accused the first report of missing that requirement. The agent's &lt;a href="https://github.com/RHIZOGRIP/spore-demos/blob/main/godot/keris/turn-2/target-audit.md" rel="noopener noreferrer"&gt;target audit&lt;/a&gt; correctly identified it as a new target. Its final report nevertheless accepted the blame.&lt;/p&gt;

&lt;p&gt;That is worth preserving in the write-up. The seven original targets passed; the second turn introduced three additional targets. Calling the first turn a failure would misrepresent the instructions it received.&lt;/p&gt;

&lt;h2&gt;
  
  
  Checking the checker
&lt;/h2&gt;

&lt;p&gt;The agent wrote both the game and its bots. Agreement between them is useful, but not independent validation.&lt;/p&gt;

&lt;p&gt;The published repository separates the agent's artifacts from the checks we added afterward:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The agent delivered the game source, bot data, attempt log and media.&lt;/li&gt;
&lt;li&gt;We added Python verification scripts to recompute results from the artifacts and compare the turns.&lt;/li&gt;
&lt;li&gt;We also added a test over &lt;strong&gt;2,000 unseen seeds&lt;/strong&gt;, because steward's rule had been tuned on the same 200 seeds used for scoring.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;On those unseen seeds, the published output reports:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Policy&lt;/th&gt;
&lt;th&gt;Win rate&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Steward, using the voice&lt;/td&gt;
&lt;td&gt;60.8%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Always accept&lt;/td&gt;
&lt;td&gt;54.6%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Never accept&lt;/td&gt;
&lt;td&gt;47.2%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Never open the gate&lt;/td&gt;
&lt;td&gt;5.3%&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The advantage held on that additional sample. This still isn't a human playtest, a proof of enjoyable gameplay, or a general evaluation of the model.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://github.com/RHIZOGRIP/spore-demos/tree/main/godot/keris#check-it-yourself" rel="noopener noreferrer"&gt;README&lt;/a&gt; explains how to recompute the artifact checks with Python, replay policies in Godot and inspect the unseen-seed output.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Spore fits
&lt;/h2&gt;

&lt;p&gt;Spore didn't supply game logic or a Godot-specific plugin. Godot ran from the command line inside the agent's sandbox; this example required no external application bridge.&lt;/p&gt;

&lt;p&gt;The runtime provided the workspace and execution environment in which the agent could keep programs and results, run tools, inspect files and continue into a second turn.&lt;/p&gt;

&lt;p&gt;The distinction matters: the model brought the reasoning and code generation. Spore provided the machinery around the work. This example doesn't isolate how much each contributed, and it doesn't establish superiority over another runtime.&lt;/p&gt;

&lt;p&gt;The recorded run used Spore 1.57.0, Godot 4.7.2 and &lt;code&gt;gpt-6.1-sol&lt;/code&gt; through a ChatGPT plan. The published timings are roughly half an hour for the first turn and three quarters of an hour for the second. There is no metered API cost for those plan-based turns; that is not a claim that execution or model access was free.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I'd take from this experiment
&lt;/h2&gt;

&lt;p&gt;The most useful result isn't “an agent can generate a game.” It's the workflow:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Make the intended behavior mechanically testable where possible.&lt;/li&gt;
&lt;li&gt;Let the agent write and reuse programs to measure it.&lt;/li&gt;
&lt;li&gt;Inspect what the acceptance targets leave out.&lt;/li&gt;
&lt;li&gt;Separate generated evidence from additional verification.&lt;/li&gt;
&lt;li&gt;Keep the remaining limitations visible.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The game is playable, not a finished commercial production. A new run may make different choices or fail. The prompts and evidence are public so you can examine more than the final video.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://play.rhizogrip.com/keris/index.html" rel="noopener noreferrer"&gt;Play Kêr-Is&lt;/a&gt;&lt;/strong&gt; · &lt;strong&gt;&lt;a href="https://github.com/RHIZOGRIP/spore-demos/tree/main/godot/keris" rel="noopener noreferrer"&gt;Inspect the experiment&lt;/a&gt;&lt;/strong&gt; · &lt;strong&gt;&lt;a href="https://github.com/RHIZOGRIP/spore" rel="noopener noreferrer"&gt;Spore source&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Next in this series: using a persistent coding agent in a Git project—running a task, reopening the workspace and inspecting what changed.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>gamedev</category>
      <category>node</category>
      <category>agents</category>
    </item>
    <item>
      <title>Mohdel 1.0: a self-hosted LLM gateway and SDK for Node</title>
      <dc:creator>Christophe Le Bars</dc:creator>
      <pubDate>Fri, 11 Sep 2026 18:07:59 +0000</pubDate>
      <link>https://dev.to/clbrge/mohdel-10-a-self-hosted-llm-gateway-and-sdk-for-node-3n03</link>
      <guid>https://dev.to/clbrge/mohdel-10-a-self-hosted-llm-gateway-and-sdk-for-node-3n03</guid>
      <description>&lt;p&gt;I released &lt;a href="https://github.com/clbrge/mohdel" rel="noopener noreferrer"&gt;mohdel&lt;/a&gt; 1.0.0 this week. It is a self-hosted LLM gateway and SDK for Node, MIT licensed, and it runs the inference layer of a document analysis product with hundreds of thousands of users.&lt;/p&gt;

&lt;p&gt;The closest thing to it is LiteLLM, which lives in Python. If your stack is JavaScript, your options have been a Python sidecar to deploy and monitor, a SaaS router sitting in your request path, or N provider SDKs with N shapes and no accounting. Mohdel is the Node-native version of that layer.&lt;/p&gt;

&lt;p&gt;Here is what it does, section by section.&lt;/p&gt;

&lt;h2&gt;
  
  
  One interface, 13 providers
&lt;/h2&gt;

&lt;p&gt;Anthropic, OpenAI, Gemini, Mistral, Groq, xAI, Cerebras, Fireworks, DeepSeek, Qwen Cloud, Xiaomi, OpenRouter, Novita, plus local inference. One call:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="nx"&gt;mohdel&lt;/span&gt; &lt;span class="k"&gt;from&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;mohdel&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;

&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;mo&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;mohdel&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nx"&gt;mo&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;use&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;anthropic/claude-sonnet-4-6&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;).&lt;/span&gt;&lt;span class="nf"&gt;answer&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;Hello&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nx"&gt;console&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;log&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;result&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;output&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;result&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;cost&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Switching provider is one string. The result shape does not move:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight javascript"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;status&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;completed&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;      &lt;span class="c1"&gt;// 'completed' | 'tool_use' | 'incomplete'&lt;/span&gt;
  &lt;span class="nx"&gt;output&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="s1"&gt;Generated text&lt;/span&gt;&lt;span class="dl"&gt;'&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nx"&gt;inputTokens&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;42&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nx"&gt;outputTokens&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;128&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;        &lt;span class="c1"&gt;// visible output, excludes thinking&lt;/span&gt;
  &lt;span class="nx"&gt;thinkingTokens&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nx"&gt;cost&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mf"&gt;0.002046&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;           &lt;span class="c1"&gt;// USD, from your catalog&lt;/span&gt;
  &lt;span class="nx"&gt;timestamps&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;start&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;first&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;end&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Tool calls, streaming, vision and speech to text go through the same call. Adapter differences stay inside mohdel: &lt;code&gt;max_tokens&lt;/code&gt; versus &lt;code&gt;max_output_tokens&lt;/code&gt;, top-level &lt;code&gt;system&lt;/code&gt; versus &lt;code&gt;instructions&lt;/code&gt;, five different usage shapes.&lt;/p&gt;

&lt;p&gt;Local models are the &lt;code&gt;local/&lt;/code&gt; provider, pointed at any OpenAI-compatible server: Ollama, vLLM, llama.cpp server, LM Studio. There is no default endpoint and no per-call override, so a call to a local model can never fall through to a cloud provider by accident.&lt;/p&gt;

&lt;h2&gt;
  
  
  Two integration paths, same API
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;In-process.&lt;/strong&gt; &lt;code&gt;import mohdel from 'mohdel'&lt;/code&gt; and call it. No subprocess, nothing to run. Right for scripts, CLI tools, tests and single-process services, which is most projects.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cross-process.&lt;/strong&gt; A Rust supervisor, &lt;code&gt;thin-gate&lt;/code&gt;, owns a pool of session subprocesses. Your app talks to it over a unix socket; the provider SDKs run somewhere else entirely. An adapter that hangs, leaks or panics takes down one session, and the supervisor respawns it while the caller gets a recoverable error.&lt;/p&gt;

&lt;p&gt;The wire between them is documented NDJSON, so a caller does not have to be JavaScript. There are reference clients in Lua, Gleam, Rust and OCaml in the repo, all validated against the same conformance fixtures.&lt;/p&gt;

&lt;p&gt;Switching between the two paths is configuration, not code.&lt;/p&gt;

&lt;h2&gt;
  
  
  Real per-call cost
&lt;/h2&gt;

&lt;p&gt;&lt;code&gt;result.cost&lt;/code&gt; is a USD number, computed from a catalog that belongs to you:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="nl"&gt;"anthropic/claude-sonnet-4-6"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"model"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"claude-sonnet-4-6"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"creator"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"anthropic"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"provider"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"anthropic"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"inputPrice"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"outputPrice"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;15&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"cacheWritePrice"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mf"&gt;3.75&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"cacheReadPrice"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mf"&gt;0.3&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"contextTokenLimit"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;1000000&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"outputTokenLimit"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="mi"&gt;128000&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt;
    &lt;/span&gt;&lt;span class="nl"&gt;"tags"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"chat"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"tool-loop"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="s2"&gt;"vision"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="w"&gt;
  &lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Yours, so it carries the rate you negotiated and the tags your routing code selects on, rather than a central price map you inherit and hope is current.&lt;/p&gt;

&lt;p&gt;The catch is that no provider publishes prices in machine-readable form: no endpoint, just a marketing page with a table and a footnote about cached reads. So mohdel writes a brief and hands the transcription to the coding agent already running in your terminal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;mo model instructions anthropic &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; mohdel-brief.md
claude &lt;span class="s2"&gt;"read mohdel-brief.md, then add claude-haiku-5 to my mohdel catalog"&lt;/span&gt;

mo model check &lt;span class="nt"&gt;--entry&lt;/span&gt; mohdel-candidate.json   &lt;span class="c"&gt;# schema, types, required fields&lt;/span&gt;
mo model apply mohdel-candidate.json           &lt;span class="c"&gt;# prints the diff, waits for you&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The agent never writes the catalog. It writes a candidate file, &lt;code&gt;check&lt;/code&gt; validates it, and &lt;code&gt;apply&lt;/code&gt; prints a full diff before anything lands. Entries record the URL the numbers came from and the date they were read, and the brief tells the agent to leave a field out rather than guess it.&lt;/p&gt;

&lt;p&gt;OpenRouter needs none of this: it publishes per-token prices in its own model list, so setup offers to add every free model in one keystroke.&lt;/p&gt;

&lt;h2&gt;
  
  
  Observability without instrumentation
&lt;/h2&gt;

&lt;p&gt;Set &lt;code&gt;OTEL_EXPORTER_OTLP_ENDPOINT&lt;/code&gt; and you get spans, trace-linked logs and OTLP metrics. The call span follows the GenAI semantic conventions (&lt;code&gt;gen_ai.request.model&lt;/code&gt;, &lt;code&gt;gen_ai.usage.input_tokens&lt;/code&gt;) and adds mohdel's own &lt;code&gt;mohdel.cost&lt;/code&gt; and &lt;code&gt;mohdel.time_to_first_token_ms&lt;/code&gt;. Pass a &lt;code&gt;traceparent&lt;/code&gt; on the call and it parents under your span.&lt;/p&gt;

&lt;p&gt;Running the gate, you also get sessions alive and respawned, calls by provider and status, a call-duration histogram, and cooldown, quota and policy rejections. Per-model and per-provider rate limits live in the catalog, and a provider that keeps failing goes into cooldown so calls fast-fail instead of hitting the wire.&lt;/p&gt;

&lt;h2&gt;
  
  
  Types, and a wire that does not move
&lt;/h2&gt;

&lt;p&gt;The source is JavaScript with JSDoc. Declarations are generated from it and ship with the package, so a TypeScript consumer typechecks against the real contract: &lt;code&gt;CallEnvelope&lt;/code&gt;, &lt;code&gt;Event&lt;/code&gt;, &lt;code&gt;AnswerResult&lt;/code&gt; and a single &lt;code&gt;MohdelError&lt;/code&gt;. No &lt;code&gt;@types&lt;/code&gt; package, nothing to keep in sync.&lt;/p&gt;

&lt;p&gt;The NDJSON protocol between client, gate and session has been frozen since 0.90 and is enforced by fixtures that both the JS and the Rust side round-trip. 1.0.0 puts that under SemVer along with the library API.&lt;/p&gt;

&lt;h2&gt;
  
  
  Your keys, and not much to steal
&lt;/h2&gt;

&lt;p&gt;Self-hosted means the keys stay in your infrastructure and calls go straight to the provider. Nothing routes through a third party and nothing marks up your tokens.&lt;/p&gt;

&lt;p&gt;The gateway itself is built to hold nothing worth taking: no network listener (the supervisor binds unix sockets at mode 0600), no credential store (the key rides on each call and goes to the SDK client), and nothing that executes, meaning no eval, no child_process, no automatic tool loop. The session subprocess starts from an empty environment and gets back only the variables the runtime reads, so a key for a provider it will never call is not in its address space.&lt;/p&gt;

&lt;p&gt;Tool execution stays in your process, where you can see it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it is not
&lt;/h2&gt;

&lt;p&gt;Not an orchestrator: no chains, no agents, no memory, no retrieval. Wrap it with whatever you like. Not a retry or fallback engine; errors are classified with &lt;code&gt;retryable&lt;/code&gt;, &lt;code&gt;severity&lt;/code&gt; and &lt;code&gt;type&lt;/code&gt;, and the caller decides. Not a response cache. Not a token budgeter.&lt;/p&gt;

&lt;p&gt;It does not expose an OpenAI-compatible endpoint, so a cross-process caller uses the JS client or implements the documented NDJSON protocol. The library and CLI run anywhere Node 22 does; the prebuilt supervisor binary is Linux x64 only so far.&lt;/p&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;



&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npm &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;-g&lt;/span&gt; mohdel
mo                           &lt;span class="c"&gt;# pick a provider, paste a key&lt;/span&gt;
mo ask openai/gpt-5.6-luna &lt;span class="s2"&gt;"why is the sky blue"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;npm install mohdel&lt;/code&gt; for the library. MIT licensed, and the issues are open: &lt;a href="https://github.com/clbrge/mohdel" rel="noopener noreferrer"&gt;https://github.com/clbrge/mohdel&lt;/a&gt;&lt;/p&gt;

</description>
      <category>javascript</category>
      <category>node</category>
      <category>showdev</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
