Submit Your Pipeline.
We Handle Everything Else.
Lugal runs large-scale, long-running data pipelines on cloud compute you never have to manage. Send us a config, get back results and a transparent bill — no orphaned instances, no surprise costs.
From Config to Results — No DevOps Required
Lugal abstracts away every layer of infrastructure so researchers and data teams can focus entirely on their science.
Submit
Upload your data to S3 and send a pipeline config via API or CLI. Lugal validates the spec and queues it immediately.
Execute
Jobs launch in sequence on dedicated cloud compute. Each job passes its output to the next — no manual handoffs.
Monitor
Heartbeats and structured logs flow back in real time. If a job fails, Lugal records the halt point and waits for your instruction.
Deliver
Your output lands in S3. Compute shuts down the moment the pipeline completes. You receive results and an itemised bill.
Lugal Is Built for These Workloads
Long-running, data-intensive pipelines that need reliable execution, automatic cost tracking, and full traceability.
Bioinformatics & Genomics
Sequencing workflows involve many tools — FastQC, alignment, variant calling, annotation — each needing different compute and producing outputs that feed the next step. Running dozens of samples in parallel while containing per-sample failures requires significant pipeline infrastructure.
one_per_input mode runs each sample through the full pipeline independently. Failed samples retry without touching clean ones. Outputs flow between steps automatically via ${taskName} references — no manual path wiring between tools.
Research Computing
Large-scale analyses — feature computation, statistical workflows, data transformations — need more compute than local machines can provide. Manually managing cloud VMs is slow, and forgetting to terminate instances leads to surprise charges.
Lugal provisions dedicated compute per job and destroys it the moment the job finishes. Failed steps restart from the exact failure point. Every run produces a complete execution record — inputs, outputs, timing — for reproducibility and peer review.
Data Science Batch Workloads
Feature engineering, model training, and evaluation pipelines have multiple interdependent steps that need different compute profiles. Managing intermediate data between steps adds fragile handoffs that are hard to monitor and debug.
Each pipeline step is a discrete job with defined inputs and outputs. Data flows automatically between steps via S3. You receive a per-step cost breakdown — not just a total bill — so you can see exactly which step consumed what compute.
Simulation & Parameter Sweeps
Running the same simulation across hundreds of parameter configurations requires tracking which inputs produced which outputs, identifying failed runs, and reproducing exact results months later without rebuilding the environment.
Each configuration runs as a discrete job. Inputs, outputs, and timing are captured in the execution record. Failed configurations retry independently, and the plan.json maps every output back to its exact input set.
Compliance-Sensitive Data Operations
Regulated workflows — clinical data processing, GxP research, HIPAA-covered pipelines — need data lineage, encryption, access controls, and audit trails as engineering requirements. Most pipeline platforms weren't designed to provide this.
Audit trails are first-class outputs. Input data expires automatically after 30 days. Every resource carries tags mapping to client, project, and run. The execution record provides timestamped evidence of exactly what ran, when, and on what input.
Full traceability. No Surprises.
Lugal was designed around a single principle: every unit of compute must be traceable to a billable job. There are no silent retries, no orphaned instances, and no untracked resources left running after a pipeline finishes.
What You Get at the End of Every Run
Every Dollar Traced to a Job
Lugal is designed so every unit of compute maps back to a specific job, pipeline, client, and execution record. The goal is to eliminate surprise cloud usage and make long-running workloads financially traceable.
Per-Job Billing Records
Each pipeline run generates a billing record tied to exactly the jobs that ran. Compute costs accumulate per job — not per pipeline as a flat unit — so you can see which step cost what.
Failed Runs Are Visible
A job that fails mid-run still records the compute it consumed. Retries are logged separately. You never receive a bill for invisible work — every charge has a corresponding execution record.
No Orphaned Compute
Lugal tracks every AWS resource it creates before it starts. Cleanup runs automatically on success or failure — no EC2 instances left running, no EBS volumes silently accruing charges.
Tagged to Client and Project
Every resource carries tags for client, project, pipeline, and job. This makes cost allocation straightforward whether you're running a single project or billing across multiple clients.
Pricing Is Custom, Not Hidden
Lugal does not publish a fixed rate card because pipeline costs depend on your compute requirements — instance types, job duration, data volume, and retry behaviour all vary by workload. We scope pricing per engagement and provide a cost estimate before any work begins.
There is no invisible markup. The itemised bill you receive maps directly to the AWS resources Lugal provisioned on your behalf.
What Happens During a Run
Submit a config. Lugal handles everything — from provisioning to teardown — and delivers a complete record when the pipeline finishes.
{
"name": "variant-calling-run-042",
"tasks": [
{
"name": "fastqc",
"mode": "one_per_input",
"restarts": 1
},
{
"name": "align",
"mode": "one_per_input",
"inputs": [
{
"path": "${fastqc}",
"filter": "*.fastq.gz"
}
],
"restarts": 2
},
{
"name": "call_variants",
"inputs": [
{
"path": "${align}",
"filter": "*.bam"
}
]
},
{
"name": "annotate",
"args": { "genome": "hg38" }
}
]
}one_per_inputRuns one task instance per input file — if fastqc receives 6 samples, 6 tasks execute concurrently."path": "${fastqc}"References the output directory of the fastqc task. No manual path wiring required.restarts: 2Lugal retries this task up to 2 times on failure. Each attempt is recorded separately in plan.json.Pipelines Are Simple to Define
A Lugal pipeline is a JSON config — a named list of jobs, each with its own tools, inputs, and outputs. No YAML sprawl, no DAG frameworks to learn.
The top-level unit. Has a name, a client, and an ordered list of jobs. Submitted once via API.
- Client & project attribution
- Ordered job sequence
- Resource quotas & retry policy
A single unit of work that runs on its own EC2 instance. Reads from S3, writes back to S3.
- Dedicated compute per job
- Defined inputs & outputs
- Configurable parallelism
The individual steps within a job — your actual tools and scripts, run in sequence.
- Your code, your tools
- Automatic input/output wiring
- Per-task retry & failure handling
Deployment and Security Model
Lugal runs in a Telos Sphere-managed AWS account. You bring data and a pipeline config — we own every layer of infrastructure.
Where Your Workload Runs
Lugal runs in a Telos Sphere-managed AWS account. You do not need to set up, configure, or share any cloud infrastructure. You bring your data and a pipeline config — everything else is on our side of the account boundary.
We provision the VPC, S3 buckets, EC2 instances, and IAM roles per engagement. When a pipeline run completes, compute is destroyed. Input data carries a 30-day automatic expiry; you retrieve outputs and records directly from S3.
What Is Retained After a Run
Available for Early Technical Conversations
Lugal is currently available for selected early technical conversations and private-preview use cases.
If you run long-running, data-heavy workloads and want better cost visibility, auditability, and operational control — contact us for a pipeline review.