Skip to content

System namespace ("sys")#

The system namespace ("sys") contains system information and some basic data about logged Neptune objects. Most of this data is logged automatically.

You cannot create new fields in the "sys" namespace, but some of their values can be edited manually (marked with * in the table below).

Field         Description Example
id Neptune identifier
  • Run ID: PROJKEY-#
  • Model version ID: PROJKEY-MODELKEY-#
custom_run_id Custom run identifier "my custom ID"
name * Name of the object "First PyTorch run"
running_time Total running time of the object in seconds 1.822
monitoring_time Total monitoring time used by the object in seconds 2
ping_time Time of the last interaction with the Neptune client library 2022-05-03 06:45:23.452364+00:00
owner Username of the user who created the object neptuner
creation_time Time the object was created 2022-04-25 07:08:05.023000+00:00
modification_time Time the object was last modified 2022-05-03 06:45:23.452364+00:00
tags * Tags applied to the object "maskRCNN", "finetune", "v2.0.1"
state Whether the object is active or inactive "inactive"
size Size of the object in bytes 6973.0
failed * (Runs only) Whether the run was marked as "failed" False
description * Description of the object "New test data"
hostname (Runs only) System host where the run was created LAPTOP-EX1000
model_id (Model versions only) Identifier of the model CLS-FOREST
stage * (Model versions only) Stage of the model version production

* The field can be manually edited, either through the app or the API.


Field Type
sys/id String

Each Run, Model, and ModelVersion object has a unique string identifier within the project.

The project key is always the first part of an object ID.

  • Run ID = project key + high water counter
    • Example: In a project called "Classification" with project key CLS, the third run will have the identifier CLS-3.
  • Model ID = project key + model key.
    • In a project called "Classification" with project key CLS, a model with key FOREST will have the identifier CLS-FOREST.
  • Model version ID = project key + model key + high water counter.
    • For a model with identifier CLS-FOREST, the third model version will have the identifier CLS-FOREST-3.

You can access the ID of your active object programmatically with the fetch() method:

>>> import neptune
>>> run = neptune.init_run(project="ml-team/classification")
>>> run_id = run["sys/id"].fetch()
>>> print(run_id)

You can use the ID to resume logging to the object later, or connect to it from multiple processes.

Custom run identifier#

Field Type
sys/custom_run_id String

The custom run identifier, if one was supplied when the run was created.

Note that it's not possible to use a custom run ID in offline mode.

import neptune
run = neptune.init_run(custom_run_id="my custom ID")


Field Type
sys/name String

Editable name of an object.

The name should capture the essence of the object in a one-sentence summary. It does not need to be unique.

You can set it in the following ways:

  • During initialization through the name parameter of the init function
  • In the app, by navigating to the object's details
  • Directly in the code:
import neptune
run = neptune.init_run(project="ml-team/classification")
run["sys/name"] = "Testing new approach"


Field Type
sys/description String

Editable description of an object.

The description field can store a longer description or free-form note about the object.

You can edit the description

  • in the code, through the API:

    import neptune
    run = neptune.init_run(project="ml-team/classification")
    run["sys/description"] = "Detailed description of the run"
  • through the Neptune app:

    • Runs:
      • Click the run menu () next to the run ID → Show run information
      • Directly in runs table, by adding the sys/description field as a column
    • Models: In the Models section, by selecting the model name and clicking Model information next to the model name
    • Model versions:
      • Directly in the Versions tab, by adding the sys/description field as a column
      • In the model version view, by clicking Model version information


For runs, you can also enter a description during initialization, through the description parameter of init_run().

Running time#

Field Type
sys/running_time Float

Total running time of the object in seconds.

This number takes into account any additional resumes of the object.

Monitoring time#

Deprecated feature

Monitoring time was the basis for's previous pricing model. It has no function in the current model, which is based on the number of active projects.

You can still access the field and display it in the runs table.

Field Type
sys/monitoring_time Integer

Total monitoring time (logging hours) used by the object in seconds.

This number takes into account any additional resumes of the object.


Neptune username of the user that created the object.

Field Type
sys/owner String

Creation time#

Field Type
sys/creation_time Datetime

Creation time of the object.

Includes date, time of day, and information about the time zone.

Modification time#

Field Type
sys/modification_time Datetime

Time that the object was last modified.

Includes date, time of day, and information about the time zone.


Field Type
sys/tags StringSet

The tags assigned to the object.

You can assign tags in the following ways:

  • (Runs only) During initialization, pass them as arguments for the tags parameter of the init_run() function
  • After initialization, with the add() method: run["sys/tags"].add("best")
  • Through the Neptune app

For more, see Add tags.


See also


Field Type
sys/state RunState

An object can be in one of two states:

  1. Active
  2. Inactive

Active means that at least one process is connected to the object. This may be a process that is logging training metrics, monitoring performance, or fetching metadata to perform further analysis.

The object automatically transitions to an Inactive state once there has been no activity for 20 seconds, typically after the script ended or you invoked stop().


"Active/inactive" does not correspond to "success/failure". The connection to a Neptune object can be paused and resumed multiple times, so Neptune does not know when the logging was a success.

Example: In the case of a run, an inactive state can mean that the run did not start, that the training or monitoring was paused, or that it did in fact finish training with a success.

When fetching the runs table programmatically, you can filter the returned table by passing values of sys/state to the state argument of the fetch_runs_table() method:

Fetching active runs from a project
import neptune
project = neptune.init_project(project="workspace-name/project-name")
runs_table_df = project.fetch_runs_table(state="active").to_pandas()


To make the states match your workflow better, you can set a custom status for each run. For example: run["info/state"] = "Success" or run["info/state"] = "Queued".


Field Type
sys/stage ModelVersionStage

A model version object can be in one of four lifecycle stages:

  • none (default)
  • staging
  • production
  • archived

You can manage the stage either through the app or programmatically with the change_stage() method.

For more, see Manage model stage.


See also


Field Type
sys/failed Boolean

Whether the run failed. You can set it manually to mark a run as failed, or reset it to False in case of resuming a failed run.

If there is a crash during monitoring, Neptune automatically sets the Failed status to True. You can override this behavior by setting the fail_on_exception parameter in init_run() to False.

In both cases, the traceback is captured and appended to the "monitoring/traceback" field. (If you provided a custom monitoring namespace for init_run(), the "traceback" field goes under that custom namespace.)

If you performed a remote abort, the Failed status will also be set to True. To learn more, see Stop or abort a run remotely.