The AI agent for coding, data analysis and anomaly detection.

Anomx

anomx is the installable Python foundation of Anomx. It ships both reusable time-series and anomaly-detection primitives and the anomx CLI agent for interactive anomaly investigation, data analysis, and platform-connected edge workflows.

The wider Anomx platform handles orchestration, workers, storage, connectors, audit trails, and human-in-the-loop review. This repository contains the portable modeling layer plus the operator-facing CLI agent that can run on any server, workstation, or laptop.

Goals

• Provide clean primitives for time-series datasets, scorers, detectors, and models.
• Support both batch and online anomaly detection workflows.
• Keep outputs interpretable: scores, thresholds, timestamps, labels, and metadata.
• Ship a practical CLI agent that is tuned for anomaly detection, time-series inspection, and data-quality analysis tasks.
• Stay modular enough to power the Anomx platform without coupling the library to the platform's storage or orchestration layer.
• Integrate with the broader time-series ecosystem, especially Darts, through optional adapters.

Installation

The package is structured for PyPI distribution:

pip install anomx

For local development:

git clone https://github.com/anomx/anomx.git
cd anomx
python -m pip install -e ".[dev]"

Optional extras:

pip install "anomx[darts]"     # Darts forecasting model adapters
pip install "anomx[docs]"      # Documentation tooling
pip install "anomx[platform]"  # Platform-facing IO and connector dependencies
pip install "anomx[release]"   # Build and PyPI publishing tooling

Python Quick Start

from anomx.datasets import make_sine_anomaly_dataset
from anomx.detectors import MovingAverageDetector
from anomx.models import NaiveSeasonalModel

dataset = make_sine_anomaly_dataset()

detector = MovingAverageDetector(window=24, threshold=3.0)
result = detector.fit_predict(dataset)
print(result.to_dataframe().tail())

model = NaiveSeasonalModel(season_length=24).fit(dataset)
forecast = model.predict(12)
print(forecast.to_dataframe())

Anomx CLI Agent

Installing the package also installs the anomx console command:

anomx

The CLI agent is meant to feel like a modern coding/data agent, but tuned for anomaly detection, time-series investigation, data quality problems, and operational analysis.

Useful startup examples:

anomx --version
anomx --print-home
anomx --provider openai --model gpt-5.5
anomx --provider anthropic --model claude-sonnet-4-6
anomx --provider kimi --model kimi-k3
anomx --ollama --model qwen3-coder:30b

Current CLI capabilities include:

• A full-screen terminal UI with persisted transcripts and session history.
• Tool blocks show the latest activity while running and a count-based summary when the agent moves on to text. Completed work folds into an expandable "Worked for ..." line, leaving the final answer visible. The Extended work visualization setting keeps the full transcript open.
• Multiple model backends: OpenAI, Anthropic, Kimi, DESY Assistant, JSC Blablador, and local Ollama.
• Five execution modes: Plan, Recommend (with a connected platform), Standard, Automatic, and Autonomous.
• Connected-platform skills for integrations, storage browsing, acquisition, datasets, jobs, model training, findings, and systems, plus user-defined skills.
• Tool-backed repository and data inspection, with optional subagents for focused parallel tasks and a persistent goal mode.
• A small inspectable home directory at ~/.anomx (or ANOMX_HOME) that stores config, auth metadata, skills, session transcripts, and a persistent private brain.

On first launch, choose whether tools run directly on your host or in a Docker or Podman container. Installed engines are selectable; missing engines stay visible but disabled. Start the chosen engine before using it. You can change the default later in /config → Manage Sandbox. Containerized chats show Secure Agent Runtime in the header.

For local host execution, the directory where you launch anomx is the task directory. The CLI home structure looks like this:

~/.anomx/
  config.toml
  auth.json
  skills/<command>/SKILL.md
  skills/<command>/references/
  brain/INDEX.md
  brain/instructions/
  sessions/index.jsonl
  sessions/usage.json
  sessions/<chat-id>/
    session.jsonl
    tmp/
    sub_agents/<name>/
      AGENT.md

brain/ and skills/ are shared across the user's chats. API and search responses go in the chat's tmp/; each delegated agent gets its own directory. Every upgraded CLI installation migrates its existing home automatically on startup, including homes selected through ANOMX_HOME; no cleanup command is needed. A versioned journal makes migration resumable after interruption and prevents repeated history scans, while a process lock coordinates concurrent launches. Authentication and configuration stay in place. Existing transcripts and custom instructions move into this layout; unassigned response/search files are preserved in sessions/_legacy/tmp/. Recorded runtime paths are repaired and historical artifact paths remain readable through the file tools. Unknown files and conflicting destination files are preserved without overwriting either version. This migration does not expire or delete old chat content. If an explicitly configured destination is on another filesystem, the affected legacy files are kept at their original location instead of blocking startup or deleting them. Close CLI processes running an older package version before upgrading: they do not participate in the new migration lock, and any legacy files they recreate are preserved.

Containerized CLI execution mounts the working project at /anomx/task and provides /anomx/brain, /anomx/skills, /anomx/tmp, and /anomx/sub_agents alongside it. /project remains an alias for the task directory. The first container start builds a local anomx-agent-runtime image with Python, Git, Node.js, and common analysis tools. This needs network access and can take a few minutes; subsequent starts reuse it. Its tag includes the installed Anomx version and recipe/source digest, so upgrading Anomx automatically prepares the matching image on the next chat turn. Each chat reuses its container until an upgrade replaces it. Mounted files persist; packages or files added only inside the container do not survive image replacement. No project files or credentials are sent to the image builder. Docker Desktop starts automatically on macOS when needed; on other hosts, start Docker or your Podman machine first. An unavailable engine produces a retryable setup message, never a silent switch to host execution. Platform agent runtimes use the same five folder names in a dedicated workspace for each chat, with attachments placed in task/ and user memory shared across chats.

Type @ to find files. Type / to open commands, including chat modes:

• /subagents Inspect this project allows delegation. Each child starts from sub_agents/<name>/AGENT.md, exchanges Markdown messages and results with the main agent, and can be asked to continue after completing its task.
• /goal Complete this task creates or uses GOAL.md in the task/project directory. The agent records progress and receives a private completion check after each apparent finish. It ends goal mode explicitly with finish_goal.
• Use /subagents:off or /goal:off in a follow-up to disable a feature.

Active features appear below the CLI's execution mode. Intermediate and final responses appear line by line; typing skips the reveal and keeps your input.

Platform Connection

When an Anomx Platform instance is available, the CLI can be connected directly from the agent UI using normal platform credentials. The platform issues a dedicated CLI-agent token, tracks the CLI host name and client version, and keeps the machine attached to the same organization context as the platform.

The agent's brain/ folder persists across sessions and synchronizes with the same user's cloud agent before and after each turn. It can hold notes, plans, and supporting files independently of the user's project. Offline edits remain local until the next successful sync. Concurrent edits preserve a conflict copy instead of silently overwriting changes. Keep credentials out of notes; sync is private to the connected account and bounded to 512 paths, 1 MiB per file, and 8 MiB total.

That makes anomx the practical edge entry point for working where the data lives first, then carrying that context back into the platform for visualization, findings, follow-up jobs, and broader analysis workflows.

Package Layout

src/anomx/
  agent/         Full-screen CLI agent, providers, skills, platform client
  data/          Connectors and sequence containers for local and edge workflows
  datasets/      TimeSeriesDataset, metadata, dataset loaders, transforms
  scorers/       Anomaly score contracts and scoring implementations
  detectors/     Batch and online anomaly detector contracts and implementations
  models/        Forecasting model contracts and baseline forecasters
  components/    Reusable component and offline pipeline abstractions
  integrations/  Optional adapters, including Darts

Darts Integration

For new flexible jobs, use the Darts-native Dataset, PyTorchModel, scorer and detector APIs and the host-provided WorkContext. See flexible jobs and ONNX training for a complete starter, backend channel loading, custom networks, and portable model publication.

pip install "anomx[ml]"
python examples/flexible_job_training.py

The default install stays lightweight. To use Darts models, install the optional extra and wrap any compatible Darts forecasting model:

from darts.models import ExponentialSmoothing

from anomx.datasets import make_sine_anomaly_dataset
from anomx.integrations import DartsForecastingModel

dataset = make_sine_anomaly_dataset()
model = DartsForecastingModel(ExponentialSmoothing())
forecast = model.fit(dataset).predict(24)

The intent is to let Anomx expose Darts-backed forecasting and anomaly workflows without making Darts a required dependency for every user.

Development

python -m pip install -e ".[dev]"
pytest
ruff check .
mypy src/anomx
python -m pip install -e ".[release]"
python -m build

Platform Context

Anomx prioritizes:

• Signal over noise: surface only relevant insights.
• Clarity over complexity: outputs should be interpretable.
• Actionability: every insight should support a decision.

The platform is designed around modular pipelines, real-time and batch workers, heterogeneous data sources, and versioned entities such as datasets, channels, jobs, runs, findings, model artifacts, and node services. This package is the focused modeling and agent layer used by that larger system.

Status

This repository is in pre-alpha stage. Public APIs and CLI ergonomics should be treated as provisional until the first stable release.

Runs and workspaces

Use anomx.init(project="experiment") and anomx.log("loss", value) for portable, step-based execution tracking. See Runs and workspace editing for offline logging, platform delivery, hosted jobs, retries, and multi-file editing.