Glossary

This page provides brief definitions for many of the terms used across Algorithmia's platform and documentation. We also provide definitions for some terms commonly used in the practice of MLOps. Things to note when using this glossary:

• Some terms have associated {PLACEHOLDER_STRING} values. We use these uppercase strings in our UI, and in code samples across our documentation, to denote generic values that must be replaced with custom values in your code. Placeholders {/beginning/with-a-slash} are endpoints from the base URL, i.e., https://CLUSTER_DOMAIN (or https://algorithmia.com for non-Enterprise clusters).

example term with placeholder {PLACEHOLDER_STRING}

Definition of first term.

example term with endpoint placeholder {/path/to/endpoint}

Definition of second term.

• Some definitions reference other glossary terms. Links are hoverable and clickable; on hover, they'll display the linked definition for quick reference, e.g.:

example term with link

This term has a hoverable link to the example term with placeholder from above.

account {ACCOUNT_NAME}

Identity on the Algorithmia platform that may own and/or be used to access a resource (e.g., an algorithm).

account profile {/users/ACCOUNT_NAME}

Profile page for an account.

admin account

See cluster admin account or org admin account.

admin API key {ADMIN_API_KEY}

API key associated with a specific cluster admin account. An admin API key can be used to make specific administrative authenticated resource requests through the API. Examples of admin-only requests include creating and deleting user accounts and organizations.

admin panel {/admin}

Navigation bar displaying administrative functionality available to a cluster admin.

algo CLI

Algorithmia’s command-line interface tool, called with algo [COMMAND [OPTIONS]].

algorithm {ALGO_NAME}

Microservice on Algorithmia that accepts an input, returns an output, and may have side effects. An algorithm can only accept a JSON blob, plain text, or binary data as input, and if it returns an output, can only return these same formats. Algorithms can be pipelined together with other algorithms. The primary use case for algorithms on Algorithmia’s platform is to provide functionality for loading and calling ML models for inference, but the scope of tasks that algorithms can perform isn't constrained to this. For example, algorithms can perform conventional deterministic algorithmic routines (e.g., binary search), can read and write data, can be used to query or send data to an external data source such as a database, can perform utility tasks such as downloading images and pre-processing structured or unstructured data, and can be configured to orchestrate all of the above.

algorithm build {ALGO_BUILD}

Specific compiled version of an algorithm, described by an algorithm build hash.

algorithm build hash {ALGO_VERSION_HASH}

Unique value describing an algorithm version created from a specific Git commit when an algorithm builds (compiles) successfully. Synonymous with algorithm version hash.

algorithm build UUID {BUILD_ID}

Globally unique identifier for a specific algorithm build, in the format 1234-1234-1234-1234.

algorithm environment

Predefined, optimized runtime configuration for an algorithm. Environments usually contain specific ML framework dependencies optimized for Algorithmia’s architecture, and serve as a base upon which additional external library dependencies can be added if necessary.

algorithm environment specification

Template specifying runtime dependencies that are included in a specific algorithm environment.

algorithm environment specification UUID {ENV_SPEC_ID}

Globally unique identifier for a specific algorithm environment specification, in the format 1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.

algorithm environment UUID {ENV_ID}

Globally unique identifier for a specific build of an algorithm environment specification, in the format 1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.

algorithm endpoint {ALGO_ENDPOINT}

Unique (within an Algorithmia cluster) name identifying a specific algorithm version, defined as ALGO_OWNER/ALGO_NAME[/ALGO_VERSION], where ALGO_VERSION defaults to the latest published version if excluded.

algorithm execution request

Request made to execute an algorithm with an optional input.

algorithm profile {/algorithms/ALGO_OWNER/ALGO_NAME}

Profile page for an algorithm.

algorithm instance {CALLER_NAME/ALGO_NAME/ALGO_VERSION}

Individual replica of an algorithm running on a worker node.

algorithm language {ALGO_LANG}

Programming language in which an algorithm is written.

algorithm owner {ALGO_OWNER}

Account or org that owns an algorithm.

algorithm pipelining

When one algorithm calls another algorithm within an Algorithmia cluster.

algorithm semantic version {X.Y.Z}

Specific published version of an algorithm build, where X, Y, and Z represent major version, minor version, and revision, respectively.

algorithm template

Source code file or collection of files with boilerplate code that serves as a unified starting point for new algorithms that are created.

algorithm UUID {ALGO_ID}

Globally unique identifier for a specific algorithm, in the format 1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.

algorithm vanity URL

Minimal URL for specific algorithm endpoint in a satellite deployment.

algorithm version {ALGO_VERSION}

Generic name to refer to a specific algorithm build, which could be denoted by an algorithm semantic version or an algorithm version hash.

algorithm version hash {ALGO_VERSION_HASH}

Unique value describing an algorithm version created from a specific Git commit when an algorithm builds (compiles) successfully. Synonymous with algorithm build hash.

API {/v1/openapispec}

Generic term for individual Algorithmia REST API service. API endpoints are grouped based on the functionality they provide for interacting with cluster resources. Algorithmia has the following APIs:

• algorithms : algorithm operations
• users : account operations
• organizations : organization operations
• scm : source code management operations
• secrets : Secret Store operations
• connectors : data connector operations
• data : data API operations
• eventlisteners : Event Flow-based operations
• eventmanagers : message broker operations
• builds : algorithm build operations
• auth : authentication factor and authentication token management
• usage : cluster usage information
• invites : cluster invite code management
• admin : cluster administration operations
• style : cluster front-end style configuration
• frontend : cluster front-end configuration

API Docs {/api}

Documentation for Algorithmia’s API, listing all available API endpoints.

API endpoint {/path/to/endpoint}

Resource URI not including the base URL, e.g., /v1/algorithms/ALGO_OWNER/ALGO_NAME/ALGO_VERSION.

API key

Generic term for a secret authentication token associated with a specific identity. As a security best practice, we recommend storing this value in the environment variable ALGORITHMIA_API_KEY.

authenticated resource request

Request for a resource that includes one or more authentication factors.

authentication

The act of signing on to the Algorithmia platform in order to gain access to an authentication token that can then be used to send authenticated resource requests.

authentication factor

Property used to authenticate into an account to access resources. Algorithmia uses passwords for authentication into our browser UI.

authentication token {AUTH_TOKEN}

Special type of authentication factor that’s granted as a digital “receipt” upon successful authentication. A token may have a validity time limit and may represent a limited set of actions that can be taken on specific resources.

authorization

The act of granting an identity access to specific resources.

base API URL {BASE_API_URL | https://api.CLUSTER_DOMAIN}

Resource URI for Algorithmia’s API, not including a specific endpoint, e.g., https://api.algorithmia.com.

base URL {BASE_URL | https://CLUSTER_DOMAIN}

Resource URI not including a specific endpoint, e.g., https://algorithmia.com.

blog {/blog}

Algorithmia site where we share practical, relevant information about ML/MLOps and the industry, describe new product features, and announce new partnerships. Algorithmia's blog is located at algorithmia.com/blog.

browser UI

Algorithmia’s browser-based user interface.

caller {CALLER_NAME}

Account associated with the authentication token used to call an algorithm.

collection owner {COLLECTION_OWNER}

Account or org that owns a hosted data collection.

closed-source algorithm

Algorithm published with source code only visible via authenticated resource requests from the account or org that owns the algorithm.

cluster

Individual instance of Algorithmia’s platform.

cluster admin account {CLUSTER_ADMIN_NAME}

Account that has administrative privileges on the cluster. Cluster admin and org admin roles aren’t related.

cluster domain {CLUSTER_DOMAIN}

Specific domain associated with an Algorithmia cluster, e.g., algorithmia.com. For usage, see base URL.

cluster operator

DevOps customer persona that works with Algorithmia I&O to deploy, upgrade, and maintain Algorithmia’s infrastructure in their Enterprise environment.

cold algorithm

Algorithm for which no instances are currently ready to process algorithm execution requests.

commit {COMMIT_HASH}

In source code management, a set of changes saved (“committed”) to a source code repository’s history. Algorithmia uses Git for source code management; in Git, commits contain metadata about the relationship between a specific commit and other commits in the history of the repository.

Constellation Distributed Serving BETA

Flexible Algorithmia deployment option in which a mothership (any Enterprise cluster with the option enabled) is distinct and separate from the satellite(s) (a set of containers including algorithms (one satellite to many algorithms), RabbitMQ, API server, and a configuration file) for production runtime, thereby decoupling algorithm development from runtime execution. Constellation enables customers with high security, high availability, or high performance workloads to easily deploy and serve models where they need to and in the environment that works best for them. NOTE: Constellation requires a separate license and fee. To learn more about Constellation and to get set up using this feature with your Algorithmia installation, please contact your customer success manager.

consumer

Not used. See subscriber.

control plane node

Node in Algorithmia’s Kubernetes environment that manages cluster health and provisioning of general purpose nodes and worker nodes. Put another way, this node runs Kubernetes—the orchestration of the containers. Note that this was previously named master node.

data connector {CONNECTOR_ID}

Specific cloud storage provider to which algorithms can connect natively through a built-in configuration on Algorithmia’s platform.

data source

Generic term for hosted data collection, data connector, or external data source.

data URI {CONNECTOR_ID://COLLECTION_OWNER/COLLECTION_NAME[/FILE_NAME]}

Identifier that describes the location of a hosted data collection or native data connector to the API. The location may be a file “bucket” (i.e., a folder or directory) or a file itself.

Developer Center {/developers}

Quick-reference Algorithmia technical documentation.

directory {DIR_NAME}

Generic term for “bucket” that can hold files. Used synonymously with folder.

Event Flow

Publisher or subscriber algorithm configured to read records from or write records to a message broker.

event listener

Not used. See Event Flow.

event manager

Not used. See message broker.

external data source

Data source to which algorithms can connect using external standard SDKs and APIs but to which Algorithmia doesn’t provide a built-in data connector accessible through the API.

file {FILE_NAME}

Generic term for file of any type (text, JSON, binary, etc.) in local, hosted, cloud, or other storage.

folder {FOLDER_NAME}

Generic term for “bucket” that can hold files. Used synonymously with directory.

general purpose node

Node in Algorithmia’s Kubernetes environment that manages and schedules Algorithmia services (with the exception of algorithm worker nodes) providing services such as logging, storage, source code management, billing, etc.

Grafana

Numeric metrics visualization dashboard provisioned with each Algorithmia Enterprise installation.

hosted data collection {COLLECTION_NAME}

Object storage hosted on the Algorithmia platform. Data collections are not “file storage” in that they can’t store nested data or data with a “/” character in the path.

hot algorithm

Algorithm instance actively handling an algorithm execution request.

HTTP method

Verb used to indicate an interaction with a resource through the REST API. Algorithmia primarily uses GET, PUT, POST, DELETE, HEAD, and PATCH methods.

JSON Web Token (JWT) {JSON_WEB_TOKEN}

Open, industry-standard RFC 7519 method for representing proof of secure communication between two parties. On Algorithmia a JWT can be used as an authentication token to grant an identity access to perform authenticated resource requests. If configured, permission tags can be extracted from a JWT and used to facilitate external management of organization membership and user security roles.

identity

Digital representation of a real-world entity that attempts to access a resource. This could be a human user, a service account, or a server, for example.

Kibana

Log query and visualization tool provisioned with each Algorithmia Enterprise installation.

machine learning (ML)

Application of artificial intelligence in which a computer system uses algorithms and statistical models to analyze and draw inferences from patterns in data, learning and adapting in order to make decisions without following explicit instructions from humans.

machine learning operations (MLOps)

The discipline of delivering ML models through repeatable and efficient workflows.

master node

Deprecated. See control plane node.

message broker

Event-processing tool that stores records from publishers in a log or queue and makes them available to be read by subscribers.

message broker connection

Connection between Algorithmia and a message broker, configured at either the cluster or algorithm level, depending on the message broker type.

ML service catalog {/algorithms}

Library of versioned algorithms ready to be served for inference.

model {MODEL_FILE}

ML model file that’s ready to be loaded into an algorithm and used for inference. Synonymous with serialized model and trained model. Also used to refer to an ML model in a general sense.

model deployment

Process of preparing trained models and deploying them so that they can be consumed programmatically by applications and/or other models.

model explainability

Ability to explain how a model was built and the reasons for its outputs. In some contexts this is used interchangeably with model interpretability.

model governance

Process for how a company controls access to models, implements policy surrounding models, and tracks activity of models.

model interpretability

Ability to understand the cause of a model decision. This can also refer to the ability for a human to understand and predict a model’s output, or the ability to observe cause and effect by changing model parameters. In some contexts this is used interchangeably with model explainability.

model monitoring

Ability to assess a model's performance, accuracy, drift, and errors.

model observability

Ability to assess the state of a model through metrics and logs, and to understand and diagnose the operational health of a model.

model validation

Ability to confirm that outputs of a model are acceptable given real-world inputs.

mothership cluster

Standard Algorithmia Enterprise cluster, consisting of a number of services for algorithm creation, management, and execution. A mothership cluster runs in an Algorithmia-installed and configured Kubernetes cluster on customer infrastructure as part of a Constellation deployment.

node

Generic term for virtualized compute resource on which Algorithmia services are run. In Algorithmia’s Kubernetes environment, a node may be a control plane node, general purpose node, or worker node.

open-source algorithm

Algorithm published with source code visible via an authenticated resource request to the cluster if it’s a public algorithm. If it’s a private algorithm, the source code is only visible via authenticated resource requests from the account that owns the algorithm.

orchestration algorithm

Algorithm that receives an API request directly from a caller and calls other algorithms internally in a pipeline. Synonymous with parent algorithm and top-level algorithm.

org/organization {ORG_NAME}

Logical construct for sharing resource access with an arbitrary number of accounts on the cluster. An org must have at least one org admin, and accounts can be members of zero, one, or multiple orgs.

org admin account{ORG_ADMIN_NAME}

Account that has elevated privileges within a specific org of which it’s a member. Anyone who creates an org is automatically given the org admin role, and an account can be an org admin for zero, one, or multiple orgs. Org admin and cluster admin roles aren’t related.

org profile {/organizations/ORG_NAME}

Profile page for an org.

parent algorithm

Algorithm that receives an API request directly from a caller and calls other algorithms internally in a pipeline. Synonymous with orchestration algorithm and top-level algorithm.

password

Authentication factor used to authenticate to access the resources associated with an account on an Algorithmia cluster.

platform version

Semantic version of Algorithmia’s software, e.g., “20.4.7” or “v20.4.7”.

private algorithm

Algorithm published privately that can only be called by the account or org that owns the algorithm, or from an account that's a member of an org that owns the algorithm.

producer

Not used. See publisher.

public algorithm

Algorithm published publicly that can be called by any authenticated account on the cluster.

publisher

Entity that sends records to a message broker. Synonymous with producer.

record

Data or message sent to or retrieved from a message broker. Also used to refer to a row of data in a relational database table.

replica {CALLER_NAME/ALGO_NAME/ALGO_VERSION}

Individual instance of a specific algorithm running on a worker node.

reservation

Algorithm instance kept warm to eliminate cold-start overhead. Reservations are only configurable by cluster admins.

resource

Data on the Algorithmia platform. Examples include algorithms, files stored on the platform or available through the platform, account information, etc.

resource request

Attempt by an identity to access a resource on the Algorithmia platform. Examples include executing an algorithm, publishing a new version of an algorithm, reading from or writing to a data source, etc.

resource URI {BASE_API_URL/path/to/endpoint}

Full path at which a resource exists, equivalent to base API URL + API endpoint.

satellite cluster {SATELLITE_ID}

Minimal version of Algorithmia Enterprise cluster with a subset of services, including algorithms, a RabbitMQ queuing system, configuration information, and an API server to handle algorithm execution requests. A satellite cluster runs in a customer-provided Kubernetes cluster on customer infrastructure as part of a Constellation deployment.

satellite launch instance {LAUNCH_ID}

Individual instance of a satellite deployment.

satellite version {SATELLITE_VERSION}

Version number associated with a specific satellite deployment. Each satellite version is configured with a specific list of included algorithms and authentication keys.

secret {SECRET_VALUE}

Sensitive value (e.g., password, token, access key, credential, etc.) stored encrypted in the Secret Store and accessed from algorithm source code through an environment variable.

Secret Store

Secure, encrypted vault that stores sensitive information such as access keys to external services.

serialized model {MODEL_FILE}

ML model file that’s ready to be loaded into an algorithm and used for inference. Synonymous with model and trained model.

service account {ACCOUNT_NAME}

Account not associated with a specific human.

slot

Deprecated. See replica.

SCM configuration {SCM_CONFIG_ID}

Cluster-level details about an SCM provider, such as provider type and URLs, configured by a cluster admin using a key-value pair generated within the SCM provider’s platform. There may be zero, one, or multiple SCM configurations for one SCM provider.

SCM connection

Account-levels details that contain credentials for connecting to an SCM provider.

SCM provider

Third-party SCM system to which an SCM configuration can be created for hosting algorithm source code outside of the Algorithmia platform.

source code management (SCM)

Process of tracking modifications to a source code repository. Synonymous with version control and source control management.

standard API key {STD_API_KEY}

API key associated with a specific account or org. As a security best practice, this value should be stored in the environment variable ALGORITHMIA_API_KEY.

subscriber

Entity that reads records from a message broker. Synonymous with consumer.

test console

The purple console at the bottom of the Web IDE, where algorithms may be executed with sample input to test their functionality after building.

top-level algorithm

Algorithm that receives an API request directly from a caller and calls other algorithms internally in a pipeline. Synonymous with orchestration algorithm and parent algorithm.

topic

Feed within a message broker to which publishers send records and from which subscribers read records.

trained model {MODEL_FILE}

ML model file that’s ready to be loaded into an algorithm and used for inference. Synonymous with model and serialized model.

user

Human interacting with the Algorithmia platform. See identity.

user account {ACCOUNT_NAME}

Account associated with a specific user.

UNILOG

Text-based metrics visualization dashboard. Unilog data is the aggregation of application and (some) Kubernetes logs from the various services in an Algorithmia cluster. These logs are used for debugging and stability monitoring by engineers, and can be accessed through Kibana by cluster admins only.

warm algorithm

Algorithm instance running on a worker node and ready to handle API requests.

Web IDE

Algorithmia’s built-in source code editor and test console, accessible through the “Source” tab from an algorithm’s profile.

worker node

Compute node in Algorithmia’s Kubernetes environment on which algorithm instances are run.