AxisAgentic: a long-horizon agent runtime that keeps the trace as the artifact
AxisAgentic: An Extensible Runtime and Trajectory-Collection Framework for Long-Horizon Agents.
At a glance
- What is it?
- AxisAgentic is a Python 3.12+ runtime for long-horizon agents that writes an append-only trace per task and reuses it for replay, evaluation and state-faithful SFT export. The interesting part is not the agent loop, it is the claim that inference and training can share one interaction history.
- Who is it for?
- Adopt AxisAgentic if you already run OpenAI-compatible models and the thing you lack is a durable record of what the model saw, not another prompt template. Skip it if you need a packaged product, a stable tagged release, or a runtime that hides provider configuration behind a hosted console.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 57 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 19, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem AxisAgentic targets: long runs where nobody can say what the model saw
Long-horizon agents fail in a way that is hard to debug. The model made a choice ten turns ago, context was compacted somewhere in the middle, a tool call was rolled back, and the transcript you saved no longer matches the state the model actually reasoned over. AxisAgentic is aimed at teams who hit that wall. The README frames it as an extensible runtime for long-horizon AI agents that also collects the trajectories produced during execution, and the design follows from that: an append-only trace is written per task, and runtime markers record rollback, context compaction and discard-all events. Replaying those markers reconstructs what the model saw at a given stage.
The audience is narrow on purpose. This is infrastructure for people building or evaluating agent systems, not an SDK for adding a chatbot to a product. The reference recipes are Web Search and WideSearch, and the README states the same extension points can support domain, general-purpose and coding agents. If your agent runs for two turns and returns a summary, the trace machinery costs you more than it gives back.
Append-only traces and the replay boundary between inference and training
The core mechanism is a single artifact with several consumers. Every task writes an append-only trace, and that trace is the common source for replay, evaluation and trajectory collection. Model clients, tools, orchestrators, datasets, evaluators, reward functions and recipe policies are all described as replaceable, which matters because it means the trace format is the contract rather than any particular model provider.
The part worth reading twice is the export boundary. Recipe exporters emit Swift Agent and related training formats with the source trace, task status and optional metadata. The README is explicit that the external training pipeline owns final correctness filters, loss masks and optimization, while AxisAgentic supplies the replay and export boundary so inference and training use the same interaction history. Trace inspection and SFT export share the same rules, so supervised examples exclude hidden history and rolled-back actions.
That is a real architectural position, not a feature list. Most agent frameworks log to a file and leave you to reconcile the log with the training data by hand. Here the reconciliation is the product. The cost is that you inherit the trace schema and its marker semantics; if your training pipeline expects a different notion of visibility, you are writing an adapter.
Installing AxisAgentic and validating a recipe without starting a run
The README requires Python 3.12 or newer and an OpenAI-compatible model endpoint, and points to docs/getting-started.md for installation, provider variables, recipe configuration, dry runs, replay and SFT export. The clone-and-setup sequence from the README is:
git clone https://github.com/XYZ-AI-Lab/AxisAgentic.git
cd AxisAgentic
python3.12 -m venv .venv
source .venv/bin/activate
./setup_env.sh
source .envs/axis_agentic_env.sh
cp .env.example .envs/.envThe environment file is where provider credentials live. .env.example lists OPENAI_MODEL, OPENAI_BASE_URL and OPENAI_API_KEY for the main provider, plus SERPER_API_KEY and SERPER_BASE_URL for web search, JINA_API_KEY and JINA_BASE_URL for scraping, E2B_API_KEY for the Python sandbox, and separate SUMMARY_LLM_* and COMPRESSION_LLM_* blocks. A JUDGE_* block exists and the comment states it defaults to the main provider. The same file notes that runtime settings such as dataset paths, output dirs, concurrency, token limits, timeouts and tool limits belong in YAML configs, not in the environment.
Once provider and dataset values are set, the README gives a dry run that validates the Web Search recipe without starting a run:
cp recipe/web_search/configs/default.yaml my-search-run.yaml
python -m recipe.web_search.runners.run_eval_config \
--config my-search-run.yaml \
--dry-runA dry run is the right first step here because it exercises configuration parsing and the strict YAML schemas before you spend money on search and model calls. What you should see is validation output rather than a running task; the README does not document the exact failure text when a required key is missing, so treat the first parse error as something to read carefully rather than something to search for.
What is not in the repository, and where the documentation goes quiet
The README states plainly that this repository does not include model weights. That is a boundary, not a defect, but it shapes what you can do on day one: you need your own endpoint or a local model client before anything runs.
There are no retrieved releases, and setup.py declares version 0.1.0. The last push to the default branch was on 2026-07-24. Nothing in the repository describes a tagged release cadence or a deprecation policy, and the README does not document rollback of the framework itself, only rollback as a runtime event recorded in the trace. If you need pinned versions with published changelogs, CHANGELOG.md exists in the repository root but its contents are not part of what can be confirmed here.
The benchmark picture also deserves care. The README reproduces comparisons for six of seven agentic benchmarks from the Aquila technical report, and then states that some baseline values come from public reports with different harnesses, tools, judges and evaluation dates, and that the figure should be treated as a benchmark-level comparison rather than a controlled universal ranking. That caveat is unusually honest and you should take it literally. It is not evidence that this runtime will improve your numbers.
One more gap: the README says nothing about concurrency limits or cost controls beyond the note that they live in YAML. For a runtime built around long runs, that is the documentation you will miss first.
AxisAgentic compared with a general-purpose agent framework
The obvious alternative is a general-purpose agent framework such as LangChain or LangGraph, where the agent loop, tool abstractions and memory are the product and observability is an add-on through callbacks or a tracing service. The difference is what sits at the center. In those frameworks you compose chains and graphs, and the record of a run is a byproduct you configure. In AxisAgentic the trace is the primary artifact and the runtime exists to keep it faithful.
That changes the failure modes. A graph framework lets you express arbitrary control flow and then asks you to instrument it. AxisAgentic gives you a smaller set of moving parts (model clients, tools, orchestrators, datasets, evaluators, reward functions, recipe policies) and a strict schema, so you get replay and export for free but you fight the schema when your control flow does not fit a recipe.
There is a second axis of difference: training. Most agent frameworks stop at execution and leave trajectory collection to you. Here the SFT exporter replays runtime visibility markers and the rollout interfaces connect execution to external training systems, with the explicit split that the external pipeline owns filters, loss masks and optimization. If you never train on your traces, that half of the project is dead weight.
Maintenance, licence and the upgrade cost you are accepting
AxisAgentic is licensed under Apache-2.0, and the README notes that unless otherwise stated the project is licensed under the Apache License 2.0, with NOTICE covering third-party attribution and licensing notes. Apache-2.0 is permissive and includes a patent grant, but the NOTICE file is the place to check before redistribution, and third-party components bundled under different terms are the usual reason a NOTICE file exists. That is a reading task, not a legal conclusion.
The practical upgrade cost is the trace format. Because replay, evaluation and SFT export all read the same markers, a change to how rollback or compaction is recorded propagates into any training data you have already exported. The repository ships tests/ and a CI workflow, and pyproject.toml configures ruff with select = ["ALL"] and a line length of 150, so contributions face a strict lint gate. That strictness is a signal about internal consistency, not a promise about release stability. With version 0.1.0 in setup.py and no retrieved releases, plan to track main rather than pin a tag, and keep your own copy of any exported trajectories you care about.
Editorial conclusion
Adopt AxisAgentic if you already run OpenAI-compatible models and the thing you lack is a durable record of what the model saw, not another prompt template. Skip it if you need a packaged product, a stable tagged release, or a runtime that hides provider configuration behind a hosted console. Before committing, run the Web Search recipe with --dry-run after copying recipe/web_search/configs/default.yaml, then read docs/architecture.md to confirm the trace format matches the training pipeline you already own.
Frequently asked questions
What does "agentic" mean in simple terms for a project like AxisAgentic?
In this repository the term describes a runtime that drives a model through multiple turns with tool orchestration, context management and recovery, rather than a single request and response. The README calls it an extensible runtime for long-horizon AI agents that also collects the trajectories produced during execution.
What does it mean for a person to be agentic, and does AxisAgentic use the word that way?
The README does not discuss people or personal traits, so that sense of the word does not appear here. AxisAgentic uses "agentic" for the runtime side: multi-turn execution, tool orchestration, context budgets, compaction, rollback, retries, recovery, self-verification and tool limits.
Why do they call it agentic AI in the AxisAgentic documentation?
The README frames the work around multi-turn execution, tool orchestration, context management, recovery and benchmark evaluation, with reference recipes for Web Search and WideSearch. The agentic label follows from those capabilities being handled by the runtime rather than by the caller.
What are agentic behaviors in the context of AxisAgentic?
The repository describes runtime behaviors rather than a taxonomy: context budgets, compaction, rollback, retries, recovery, self-verification and tool limits. Each of these is recorded in the append-only trace, and the markers let a replay reconstruct what the model saw at a given stage.
Community notes