Accelerator Docs

Appearance

Routine ​

On the Accelerator platform, the term Routine refers to any runnable code or software together with a declaration of the stack on which to run it. This abstraction thus represents an actionable unit of computation that can be as small as a single script and range up to a full research model. Users can encapsulate existing software as a routine that can be run as Job on the orchestration environment provided by the platform.

📦 What is a Routine? ​

A routine is essentially a wrapper around an existing piece of executable code. This means that users can onboard existing software onto the platform with minimal friction, maintaining backward compatibility while unlocking new orchestration capabilities. This approach ensures that whether you are working with legacy code, a freshly written module, or third-party software, you can transform it into a routine and orchestrate how to run it.

🔗 Features and Capabilities ​

🧱 Modular Composition and Coupling ​

Once your code and its stack is wrapped as a routine, you can run it one or more times as a single job. Jobs can

  • Automatically source their required input data.
  • Exchange intermediate data with other jobs.
  • Report their status, logs, and metrics in real-time to the central monitoring system.

The platform also enables you to compose jobflows by connecting multiple routines together. A jobflow then runs as a particular ordering of jobs instantiated from these routines. This promotes a modular architecture, where individual routines remain independently maintainable yet can be composed into a larger whole.

📍 Flexible Code Source ​

The framework supports a variety of sources from which executable code for a routine can be picked up:

  • Local File System: Useful during development and testing.
  • Remote Git Repositories: Ideal for version-controlled project modules.
  • Container Image Registries: Useful for containerized, production-ready routines.

This flexibility allows users to organize, version, and distribute their routines in a way that best fits their development and deployment workflows.

🚀 Running routines ​

🖥️ From CLI ​

Users can run routines using a client that provides a command line interface (CLI). This is ideal for:

  • Fast iteration during development
  • Scripting and automation
  • Integrating with existing CI/CD pipelines

🌐 From Web Client ​

For users who prefer a graphical interface or need to interact with pre-configured routines, the web client offers an intuitive way to:

  • Run routines with customized input parameters
  • Monitor job execution status
  • Review logs and outputs
  • Share and reuse routines within teams or organizations

🧪 Experimental vs. Stable Routines ​

The platform supports different usage modes depending on the maturity and stability of your routine:

🔬 Experimental Routines ​

These are routines still under active development or experimentation. Typically:

  • The logic is subject to frequent changes.
  • They are executed directly from the developer’s local machine.
  • Ideal for prototyping, debugging, and early-stage testing.

📦 Stable Routines ​

These are well-tested, production-ready routines with a stable codebase. Typically:

  • The logic is not expected to change frequently.
  • Only the configuration or input parameters change per execution.
  • These routines can be uploaded to the platform (called the accelerator) and executed from the web client.

This allows teams to showcase workflows, perform demonstrations, or standardize recurring workloads with little effort.

🎯 Summary of Benefits ​

  • No Code Modification Required: Existing logic can be integrated as-is.
  • Modular Design: Promotes reusable, testable, and maintainable code.
  • Execution Flexibility: Supports both CLI and web-based of orchestration of workloads.
  • Supports the Full Dev-to-Prod Lifecycle: From experimentation to deployment.
  • Integrated Monitoring and Management: Real-time visibility into job execution.