Your Python, PowerShell or Bash Shell

Three ready-made clients — one per interactive shell — so the provider is a function call in the shell you already have open. Any model, streaming, and the tool-calling agent loop.

If you live in a Python REPL, a PowerShell session or a Bash prompt, these clients are the shortest path. Each is a single dependency-free file served from this site, so you can download it, read it, and source or import it. No package to install, no PATH to change.

Python — a REPL, a notebook or a script

from zyraxon import Zyraxon

ai = Zyraxon()                       # any model; ai.models() lists them live
print(ai.ask("explain what a race condition is"))

for piece in ai.stream("write a haiku about the sea"):
    print(piece, end="", flush=True)

print(ai.ask("and the same in Go?"))  # the conversation is remembered

Download it: curl -fsSL https://zyraxonai.lovable.app/integrations/zyraxon.py -o zyraxon.py.

• ▸Zyraxon(model=..., base_url=..., api_key=...) — every setting has an environment-variable default.
• ▸ai.ask(prompt) — one turn, whole reply as a string.
• ▸ai.stream(prompt) — a generator, so the reply can be printed or forwarded as it arrives.
• ▸ai.models() — every model the provider serves, with its live context window and modalities.
• ▸ai.reset() — forget the conversation, keeping any system message.
• ▸ai.agent(prompt, tools, run) — the tool-calling loop, with your tools.

PowerShell — Windows PowerShell and PowerShell 7

. .\zyraxon.ps1

Get-ZyraxonModels
Invoke-Zyraxon "explain what a race condition is"
Invoke-Zyraxon "write a haiku about the sea" -Stream
Invoke-ZyraxonAgent "create hello.py that prints hi, then run it" -Confirm

Download it: Invoke-WebRequest https://zyraxonai.lovable.app/integrations/zyraxon.ps1 -OutFile zyraxon.ps1.

• ▸Invoke-Zyraxon "..." returns the reply; add -Stream to watch it arrive.
• ▸-Model <id> picks a model for one turn; Set-ZyraxonConfig -Model <id> sets it for the session.
• ▸Get-ZyraxonModels lists every model the provider serves.
• ▸Invoke-ZyraxonAgent "..." -Confirm runs the tool loop and asks before writing or executing.

Bash and zsh — source it in the shell you have open

. ./zyraxon.sh

zyraxon_models
zyraxon_ask "explain what a race condition is"
zyraxon_stream "write a haiku about the sea"
git diff HEAD~1 | zyraxon_ask "review this change and flag anything risky"

Download it: curl -fsSL https://zyraxonai.lovable.app/integrations/zyraxon.sh -o zyraxon.sh.

• ▸zyraxon_ask [-m model] "..." returns the reply; a piped stdin is the prompt.
• ▸zyraxon_stream prints as it arrives.
• ▸zyraxon_agent runs the tool loop; it asks before writing or executing.
• ▸zyraxon_models lists every model the provider serves.

Work that runs for hours, and is never lost

A single HTTP request cannot live for hours — a dropped network, a restart, a deploy or a rate limit will end it. So for a long job the clients do not rely on one request. They keep the whole run in a file under ~/.zyraxon/sessions, rewrite it after every completed step, and resume from it after anything interrupts the run.

The effect: you start a job and walk away. Hours or days later it is still going. If the machine reboots in the middle, you start it again with the same session name and it continues from the last step instead of beginning again.

# A job that runs for hours, and is never lost.
#
# A single HTTP request cannot live for hours — a dropped network, a restart or
# a deploy ends it. So the run is kept in ~/.zyraxon/sessions/<name>.json,
# rewritten after every step, and resumes from there after any interruption.
# Stop it, kill it, reboot the machine: start it again with the same session
# name and it continues from the last step instead of starting over.

from zyraxon import Zyraxon, local_tools

ai = Zyraxon(model="zyraxon-apex")
tools, run = local_tools(confirm=False)

result = ai.long_task(
    "Rewrite every file under src/lib, one file per step, keeping the tests green.",
    tools,
    run,
    session="refactor",          # same name resumes this run
    hours=0,                     # 0 = keep going until the task is done
    on_step=lambda s: print(f"step {s['step']}"),   # progress as it goes
)
print(result)

# From a shell, the same thing:
#   python zyraxon.py --long --session refactor "rewrite each file in src"
#   python zyraxon.py --sessions          # see saved runs and their step

• ▸session names the run. Start again with the same name to resume it.
• ▸hours=0 keeps going until the task finishes. Set a number to stop after that many hours.
• ▸The checkpoint is written after every step and written atomically, so a crash mid-write cannot corrupt it.
• ▸Any interruption — a dropped network, a 429/502/503, a killed process, a reboot — is caught and the loop continues from the checkpoint.
• ▸on_step is called after each turn, so you can log progress or show it.

From a shell

# Python
python zyraxon.py --long --session refactor "rewrite each file in src, one at a time"
python zyraxon.py --sessions            # see the saved runs and their step

# Bash / zsh
zyraxon_long -s refactor "rewrite each file in src"
zyraxon_sessions

# PowerShell
Invoke-ZyraxonLong "rewrite each file in src" -Session refactor
Get-ZyraxonSessions

The rules, for every client

• ▸Base URL https://zyraxonai.lovable.app/api/public/zyraxon/v1; model any id from https://zyraxonai.lovable.app/api/public/zyraxon/v1/models; API key any non-empty string unless the operator set a real one.
• ▸Retries the transient codes (429, 502, 503) with a short backoff, and does not retry 400, 401 or 413.
• ▸Every client names the ZYRAXON model in the reply, never an upstream.
• ▸The agent tools are confined to the current directory and ask before they write or run. They are deliberately not a general shell escape hatch.