Neptune.ai is an experiment tracking and model metadata management platform for ML teams. It provides experiment comparison, model registration, monitoring dashboards and team collaboration capabilities, and supports mainstream ML frameworks.

Neptune.ai

Core parameters and statistics

Neptune.ai is positioned as "the most scalable experiment tracker built specifically for monitoring and debugging foundation model training". It core solves the problem of "experimental indicators are scattered in distributed nodes and cannot be systematically compared and reproduced" in large model training scenarios. After being acquired by OpenAI in December 2025, the SaaS service will be officially shut down on March 5, 2026. It is currently only open to existing customers and will no longer accept new registrations.

Projects	Public Information
Official positioning	The most scalable experiment tracker, specially designed for base model training monitoring and debugging
Deployment method	Cloud SaaS (stopped), self-hosted (private cloud, new deployment has stopped)
Service status	Acquired by OpenAI on 2025-12-03, shut down on 2026-03-05
Supported frameworks	PyTorch, TensorFlow, JAX, scikit-learn, XGBoost, LightGBM
Integrated pipelines	Airflow, Kubeflow, Prefect, MLflow, ZenML, Comet
Data form	Indicators, hyperparameters, code snapshots, model weights, dataset versions, histograms, file sequence JSON
Python client	neptune-scale (logging), neptune-query (data query)
Python version requirements	3.10+
Place of Belonging	Poland (PL)
Support Platform	Web, API
Supported languages	English

Positioning difference with MLflow / W&B: MLflow is an open source lightweight experiment tracking, Weights & Biases focuses on interactive visualization and collaboration, and Neptune is more focused on scale scalability, indicator aggregation and team collaboration of distributed training, and is especially suitable for training kilocalorie base model scenarios. The core intention of OpenAI’s acquisition of Neptune is to deeply integrate it into its own training infrastructure stack to gain more fine-grained visibility into the model learning process.

Product Lifecycle Status: Neptune has entered an orderly shutdown phase. Existing customers need to complete the data export before March 5, 2026. The official provides the Neptune Exporter tool and migration guides for GoodSeed, W&B, Comet, Lightning AI, ZenML, Minfx.ai, Pluto and other platforms.

User and market recognition

Neptune's market recognition is reflected in its wholly-owned acquisition by OpenAI itself - this is the most iconic exit case in the experimental tracking track to date, directly confirming the engineering value of its technology stack in large-scale model training scenarios.

Acquired by OpenAI: On December 3, 2025, OpenAI officially announced the signing of a final acquisition agreement with Neptune. OpenAI chief scientist Jakub Pachocki publicly stated: "Neptune has built a fast and accurate system that enables researchers to analyze complex training workflows. We plan to iterate with them to deeply integrate their tools into our training stack to expand our visibility into the model learning process." This public endorsement directly illustrates Neptune's technical barriers in the field of kilocalorie-level distributed training observations.

Community and open source ecosystem: Neptune's log client (neptune-scale) and query client (neptune-query) are both publicly maintained on GitHub, and it has accumulated a stable ecosystem of contributors and integrations during its active period. The documentation site shows that its App version number continues to iterate to 3.20251215, and the SDK release frequency will reach an average of 2-3 versions per month in the second half of 2025, reflecting the density of engineering investment by the product team.

Customer structure: Although the specific customer list and revenue data are not disclosed, it can be inferred from its functional positioning (base model training monitoring) and OpenAI’s acquisition intention that its core users are mainly research institutions engaged in large-scale model training, AI laboratories of large technology companies, and cutting-edge AGI entrepreneurial teams. The product design’s native support for distributed context, side-by-side comparison of thousands-level experiments, and multi-process concurrent logs further confirms this customer group profile.

Cost advantage

• C-side/Individual: Usually a free version is provided to experience the core functions, and high-frequency use requires a paid package subscription.
• API/Developer: Billed by call volume, suitable for development teams that can be flexibly integrated into their own systems.
• Enterprise/Privatization: Contact the business owner to obtain customized quotation and deployment plan. The specific price is subject to the official real-time pricing page.

Neptune.ai’s main features

Neptune's capabilities are designed around "concentrating the observability of distributed training into one platform", and its public capabilities can be summarized into six modules:

• Distributed Experiment Tracking: Concurrent logs from multiple independent processes through the neptune-scale SDK, supporting automatic recording of hyperparameters, indicators, code versions and hardware utilization. The Run object supports creation, recovery, branching (fork) and inheritance. When branching, you can choose to inherit configuration and pre-branch indicator values.
• Large-scale indicator visualization: Web App provides customizable chart components, supporting surface overlay of thousands-level experiments, error band highlighting, outlier identification EMA smoothing, logarithmic axis, and rendering of NaN/Infinity values. The chart can switch between floating legend and bottom adsorption legend, and supports screenshot mode.
• Side-by-side comparison and difference highlighting: Side-by-side view compares configurations, scores, and other values ​​of a large number of experiments in a tabular format, providing full display on hover for long strings, displaying only difference rows to reduce information overload.
• Model Registration and Metadata Management: Centrally manage model versions, metadata and approval status, and have two-way interconnection with experiment tracking data. Supports recording nested dictionary JSON files, file sequences, images, audio and videos under Run's attribute namespace.
• Customized Dashboards and Reports: Drag-and-drop to build monitoring dashboards, support dynamic sections and custom code widgets, and embed interactive Python code directly in reports. A versioned snapshot that cannot be overwritten is generated after the report is published.
• Team collaboration and permission governance: Two-level RBAC based on workspace and project, supporting role read-only/read-write/administrator granularity. Dashboards, charts and reports can be shared in real time via persistent links, and service accounts are supported to share credentials between machines.

Expert View: The most unique synergy of Neptune is "distributed log + metadata inheritance" - in a kilocalorie training scenario, a single experiment may span dozens of processes. Neptune allows concurrent writing of indicators from multiple processes to the same run, and supports inheritance of configuration and historical indicators when branching out from the parent run into a new run. This means researchers can quickly derive variant experiments based on a set of baseline experiments without having to repeatedly record common parameters. This "fork-and-inherit" mode directly reuses the branching thinking in code engineering, reducing the amount of duplicate log data while maintaining the traceability of the experimental context.

Version evolution of Neptune.ai

Neptune has gone through a complete stage in the product life cycle from initial verification to acquisition and shutdown. The following summarizes the key nodes according to the timeline:

Early Stage: Experiment Tracking v1.x (~2022–2024)

Neptune initially entered the market as a lightweight experiment tracking tool, providing a Python SDK and a basic web panel. The official version number system at this stage will not be disclosed to the public, and product iterations will focus on feature releases.

Scale stage: v3.x + dual API system (2025)

2025 is the period when Neptune’s function density will increase most significantly, with the SDK release frequency reaching an average of 2–3 versions per month:

• 2025-05: App 3.4.11, introduces file sequence logs (log_files), supports series histogram EMA smoothing algorithm, and migrates console logs from system to runtime namespace.
• 2025-06: App 3.4.12, introduces histogram sequence and feedforward step support for branch experiments; App 3.4.13, introduces file sequence component and floating legend API Cheat Sheet.
• 2025-07: Client 0.17.0 supports GCS file upload; 0.18.0 supports nested dictionary logs; App 3.4.14 enhances chart smoothing and floating-point legend interaction.
• 2025-08: App 3.5 introduces homepage, experimental chart zoom function, and custom error bands; client 0.21.0 refactors the Run constructor; neptune-query 1.0+ officially replaces the Fetcher API.
• 2025-09 to 2025-10: App 3.20250908+ introduces CVD-friendly color palette JSON file viewing, dynamic Kanban partition, and custom code components; Query API continues to be enhanced (fetch_metric_buckets, file download NaN/Inf query).
• 2025-11: App 3.20251103.3 introduces the official version of dynamic Kanban partition and custom code components.

Shutdown Phase: Acquisition and Orderly Exit (2025-12 to 2026-03)

• 2025-12-03: OpenAI announced the acquisition of Neptune and released the Transition Hub and Neptune Exporter data export tools on the same day.
• 2025-12 to 2026-02: Migration guides for GoodSeed, W&B, Comet, Lightning AI, ZenML, Minfx.ai, Pluto are continuously released; App and SDK continue to release maintenance versions (3.20251215.1, neptune-query 1.11.0).
• 2026-03-05: The Neptune SaaS service is officially shut down, and all remaining data is deleted and cannot be recovered.
• 2026-03-08: Self-hosted customer Helm repository and container image repository deleted.

Milestone	Date	Event
v1.0 released	~2022-03	No official precise date yet
v3.x mainline iteration	2025-05 to 2025-11	Average 2–3 SDK versions per month, feature-intensive releases
Acquired by OpenAI	2025-12-03	Publicly signed final acquisition agreement
SaaS service shut down	2026-03-05	All data deleted and irrecoverable
Warehouse cleanup	2026-03-08	Helm warehouse and container image warehouse deletion

Neptune.ai’s technical advantages

Neptune's technical advantage lies not in "the most functions", but in "providing a depth of observation for distributed large model training scenarios that other experimental tracking tools cannot replace." Its core mechanism can be broken down into three points:

Concurrent log architecture for distributed training: Neptune's log client (neptune-scale) natively supports writing metrics from multiple independent processes to the same Run at the same time. In the kilocalorie training scenario, each GPU node can call run.log_metrics() independently, and the client will asynchronously batch merge and write to the backend. The engineering value of this architecture is that researchers do not need to manually aggregate the indicators of each node, nor do they need to deploy independent log aggregation middleware. The Neptune client naturally assumes the role of "distributed metrics aggregator". In contrast, MLflow's automatic log is more suitable for stand-alone experiments. Weights & Biases's concurrent writing behavior may cause conflicts or bottlenecks when there are thousands of processes.

"Fork-and-Inherit" experiment branching mechanism: Neptune allows new experiments to be branched (fork) from existing Runs, and child Runs can choose to inherit the configuration and pre-branch history indicators of the parent Run. The deep value of this mechanism is not only to reduce duplicate log data, but also to naturally establish an "evolution tree" between experiments. Researchers can intuitively trace "which baseline experiment this variant evolved from and what adjustments were made to the parameters." The document discloses a NeptuneRunConflicting error that specifically handles branch conflicts - when an inheritance conflict occurs when branching, the system downgrades to warning instead of blocking the process, reflecting the consideration of fault tolerance for large-scale experiments.

Query API and regular filtering capabilities: neptune-query provides experimental filtering syntax based on extended regular expressions (extended regex), supports AND, NOT and grouping operators, and can quickly locate qualified targets in thousands of experiments. The fetch_experiments_table_global() and fetch_runs_table_global() functions further support global searches across projects and workspaces. This capability is particularly critical when the number of experiments has expanded to the point where it is difficult to browse manually - it makes "programmatic experiment analysis" possible. Researchers can write analysis scripts to automatically screen out historical experiments that meet specific conditions for aggregation and comparison.

Cost of technical architecture: The hidden cost of this architecture is that the client relies on asynchronous batch upload, which may cause data loss when the network is unstable or the backend is delayed (the document specifically mentions "if a single data point log fails, the synchronization process will not stop"); in addition, Python requires the standard practice of "main guard" (if __name__ == "__main__"), which is easily ignored in interactive contexts such as Jupyter Notebook, resulting in abnormal process creation.

How to use Neptune.ai

Important note: The Neptune service has been shut down on March 5, 2026. The following content is only for the reference of existing users before the shutdown. New users cannot register or use.

Export existing user data

For existing customers who need to complete data migration before shutdown, Neptune provides a three-tier tool chain:

1. Neptune Exporter: The official export command line tool supports filtering and exporting by project, time range or experiment name. The exported content includes indicator sequences, configuration parameters, code snapshots, model weight metadata, and dashboard/report configurations.
2. Migration Target Platform Wizard: The documentation station Transition Hub provides step-by-step migration guides for GoodSeed, W&B, Comet, Lightning AI, ZenML, Minfx.ai, and Pluto, including data format conversion recommendations and API mapping comparisons.
3. Best Practices for Accelerated Export: The document clearly recommends improving export performance by limiting attribute ranges, excluding unnecessary namespaces, and using parallel export tasks to avoid concentrated operations at the last moment before shutdown.

Integration method (historical reference)

Typical integration links for Neptune are as follows:

Training Script → neptune-scale SDK → Neptune SaaS/Self-Hosted Backend → Web App
                              ↓
                     neptune-query SDK → Programmatic Analysis

Python integrated core code patterns:

from neptune_scale import Run

run = Run(
    experiment_name="experiment-001",
)
run.log_configs({
    "parameters/learning_rate": 0.001,
    "parameters/batch_size": 64,
})
run.log_metrics(
    data={
        "metrics/accuracy": acc,
        "metrics/loss": loss,
    },
    step=1,
)
run.close()

Query export example:

import neptune_query as nq

# List experiments that match the regular pattern
nq.list_experiments(experiments=r"regex_pattern")

# Get the configuration and indicators of the specified experiment
nq.fetch_experiments_table(
    project="workspace/project",
    experiments=r"exp_name_regex",
    attributes=r"config | loss",
)

Neptune.ai Product Pricing

Neptune's pricing system has lost its practical relevance after the acquisition. The following is compiled based on historical public information for users who have purchased to understand the past fee structure:

C-side/Personal (History): The Free plan contains a limited number of projects and members, and is suitable for getting started with personal experiment tracking. The storage capacity and concurrent log channels are limited and will not be available after shutdown.

Developer/Team (History): The Team plan is billed based on seats + storage, with discounts for annual payments; there is no additional billing for API calls. It is no longer available after shutdown, and existing users will be refunded or service terminated according to the terms of the contract.

Enterprise/Private (Historical): The Enterprise plan provides self-hosted SSO, audit logs and customized storage quotas. Prices need to be confirmed by business. Self-hosted customers have an account manager coordinating the migration path after acquisition.

Financial processing after shutdown: According to the Transition Hub FAQ, bills and renewals during the shutdown period (2025-12-03 to 2026-03-05) are handled according to the terms of the contract, and users can download historical invoices and receipts. SaaS data will be deleted and irrecoverable after shutdown. Users must ensure that the data export is completed before shutting down.

Application scenarios of Neptune.ai

Typical application scenarios of Neptune are concentrated in areas that require large-scale distributed training observations. The following are the three most representative categories:

• Base model pre-training monitoring: In a kilocalorie-level distributed training environment, Neptune acts as a "training console", aggregating real-time indicators such as loss, learning rate, and gradient norm of each node, and monitoring training stability through a custom dashboard. The key points of the verification are: the client's log writing success rate under high concurrency, the board rendering delay, and the alarm response speed of abnormal indicators (NaN, gradient explosion).
• Hyperparameter search and experimental comparison: The research team used Neptune's Side-by-side view and regular filtering capabilities to quickly locate the optimal parameter combination in large-scale hyperparameter grid search or Bayesian optimization experiments. The key points of verification are: the response time of filtering queries, the integrity of inheritance after experimental branches, and the rendering performance when charts are overlaid.
• Model version management and audit tracking: In scenarios with high compliance requirements (such as medical and financial AI), Neptune's model registry and automatic code snapshots form an auditable link of "experiment → model → deployment". The focus of the verification is: the flexibility of model approval status flow, the integrity of the correlation between code snapshots and experiments, and the fine-grainedness of RBAC permission isolation.

Applicable people

Neptune mainly serves three types of roles during its life cycle:

• Large Model Researcher: Need to systematically record and compare distributed training experiments, and have rigid requirements for the scale of indicator aggregation (thousand-level experiments, millions of data points). Neptune's concurrent log architecture and regular filtering capabilities directly respond to such needs.
• MLOps Engineering Team: Experiment tracking needs to be integrated into the production pipeline, with depth of integration with Airflow/Kubeflow as a key evaluation dimension. Neptune’s pipeline routing and intermediate metric monitoring capabilities enable engineering teams to maintain observability during large-scale training.
• AI Research Team Manager: A unified experimental management view across projects and members is required, and the ability to share permissions, audit logs, and reports is important.

Not suitable for boundaries: Neptune is not suitable for the following scenarios - first, single-person rapid experiments or small projects (Excel or local logs are enough); second, teams that want experiment tracking to be completely open source and not dependent on external SaaS (although self-hosting is provided, it is no longer available after shutdown); third, production environments that require strong compliance data residency and long-term stable service guarantees (service shutdown is irreversible). For these scenarios, migrating to W&B, MLflow or Comet is a more suitable option.

Summary and Outlook

The core value of Neptune.ai is that it proved the real existence of the need to "provide dedicated experimental tracking infrastructure for distributed large model training", and verified the engineering barriers of its technology route by being acquired by OpenAI. It is not the most comprehensive experiment tracking tool, but in terms of the concurrent log architecture Fork-and-Inherit experimental branch, regular filtering and other dimensions, it provides a depth of observation for large-scale training scenarios that is difficult to replace with other tools at the time.

CURRENT LIMITATIONS AND RISKS: Neptune has reached endgame - the SaaS service has been completely shut down, the data is unrecoverable, and the self-hosted warehouse has been cleaned. For historical users, the biggest risk is failure to complete the complete data export before shutdown, resulting in the permanent loss of experimental records, model metadata, and dashboard configurations. Even if the export is completed, the mapping from Neptune's metadata format to alternative platforms (W&B, MLflow, Comet, etc.) still requires manual verification. In particular, the relationships between chart configurations, Kanban layouts, and code snapshots may not be perfectly migrated.

Historical significance to the industry: The case of OpenAI's acquisition of Neptune set a "ceiling" for the experiment tracking track - when your experiment tracking tool goes deep enough into the core workflow of large model training, it has the opportunity to become part of the infrastructure layer and be strategically acquired. This signal also has reference value for competing products such as W&B, Comet, and MLflow.

Inspiration for potential buyers: Although Neptune is no longer available, its product cycle provides two decision-making references: First, for teams that require large-scale training and observation, when evaluating alternative platforms, they should first check the upper limit of the scale of their concurrent log architecture (how many process writes can be supported at the same time, how many seconds of data aggregation delay); second, the data migration cost of the experimental tracking platform cannot be ignored, and a platform with a standard data export format and an active migration ecosystem should be given priority to avoid being locked in by a single supplier.

Related tools: Hugging Face, replicate

Neptune.ai’s model and version evolution

Continuous iterative updates, the latest version introduces performance optimization and new features. Historical version information can be viewed on the official release page. There is no complete public version evolution timeline yet. It is recommended to pay attention to the official announcement to understand the rhythm of feature updates.

How to use Neptune.ai

• Web client: You can use it by visiting the official website and registering an account. Most functions do not require installation.
• API Access: Provides RESTful API, developers can obtain the API Key and integrate it into their own applications.

Version Info

• Neptune June 2026 Update ：A continuously iterative SaaS platform with no fixed version number yet. （2026-06）
• Neptune 1.0 officially released ：There is no official precise date yet. （~2022-03）