Skip to content

System namespace ("sys")#

The system namespace (sys) contains system information and some basic metadata on the run or model object. This includes the ID, name, timestamps, and status information. 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-#
  • Run ID: NLI-8
  • Model version ID: NLI-PRETRAINED-7
custom_run_id Custom run identifier hashlib.md5(str(time.time()).encode()).hexdigest()
name * Name of the object "mellow-panda"
creation_time When the object was created 2022-04-25 07:08:05.023000+00:00
owner Name of the account that created the object jackie
tags * Tags applied to the object "maskRCNN", "finetune", "v2.0.1"
description * Description of the object "New test data"
running_time Total running time of the object in seconds 1.822
modification_time When the object was last modified 2022-05-03 06:45:23.452364+00:00
ping_time Last interaction with the Neptune client 2022-05-04 11:20:01.763951+00:00
state Whether the object is active or inactive "inactive"
failed * (Runs only) Whether the run is marked as "failed" False
size Size of the object in bytes 6973.0
hostname (Runs only) System host where the run was created LAPTOP-EX1000
model_id (Model versions only) Identifier of the parent model NLI-PRETRAINED
stage * (Model versions only) Stage of the model version production
monitoring_time Total monitoring time used by the object in seconds 182

* Editable field

Identifier (ID)#

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:

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

You can use the ID to resume logging later, access the metadata in read-only mode, or trash the object.

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 hashlib
import time

run = neptune.init_run(


Field Type
sys/name String

Editable name of an object.

It doesn't need to be unique, but you can use it as a human-friendly ID.

You can set it in the following ways:

  • During initialization with the name parameter of the init function:

    run = neptune.init_run(name="mellow-panda")
  • In the app, by navigating to the object's details.

  • After creating the object, by assigning a string to the sys/name field:

    >>> run = neptune.init_run()
    >>> run["sys/name"] = "sleepy-swallow"


Field Type
sys/description String

Editable description of a run or model object.

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

You can add a description with the description parameter of init_run():

run = neptune.init_run(description="My longer description of the run")

You can also add or edit descriptions through the web app:

  • Click the run menu () next to the run ID → Show run information.
  • In runs table, add the sys/description field as a column. You can then edit the contents of the cell.
Editing description of Model objects
  • Models: Select the model and click Model information next to the model name.
  • Model versions: To access the description:
    • In the Versions table, add the sys/description field as a column.
    • In the model version view, click Model version information.

When initializing a model object via API, you can enter a description by assigning a string to the sys/description field:

model = neptune.init_model(...)
model["sys/description"] = "Classification model trained on brand new dataset"

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.

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.

Ping time#

Field Type
sys/ping_time Datetime

Time of the last interaction with the Neptune client library. That is, when something was last logged by the API.

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


Field Type
sys/owner String

Neptune username of the user or service account that created the object.

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. This could be any kind of edit, such as setting a description or removing a tag through the app.

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 as list to the tags argument of the init_run() function:

    run = neptune.init_run(tags=["maskRCNN", "finetune"])
  • After creating the run or model object, 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:

  • Active
  • Inactive

Active means that at least one process is connected to the object. This may be a process that is logging training metrics or monitoring performance.

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

Connecting to an inactive run (or other object) in read-only mode doesn't change the state to active.


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

Example: In the case of a run, an inactive state can mean that the run didn't 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:

Fetch 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()

Customization tip

To make the states match your workflow better, you can set a custom status for each run. For example:

  • run["info/state"] = "Success"
  • run["info/state"] = "Queued"

You can also define Boolean fields:

  • run["info/success"] = True
  • run["info/queued"] = False


Field Type
sys/size Float

Size of the run or model object in bytes.

Fetch all stored models and sort by size (space taken up in Neptune)
>>> project = neptune.init_project(project="ml-team/nlu", mode="read-only")
>>> models_table_df = project.fetch_models_table(sort_by="sys/size").to_pandas()


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.