Pipelines · Editframe Factory

Process video without building the pipeline stack.

Prepare recordings, coordinate AI analysis, review findings and recover failed work. Define versioned video workflows around your own services without operating a custom system of media jobs, dependencies and retries.

Discuss your pipelineRead pipeline docs

Video processing is more than calling a model.

Define your processing workflow once and run it across collections of videos. Factory handles media preparation, dependency-aware execution and retries around the analysis services you already use.

Coordinate work across recordings and batches, with controls over how many runs and requests can be in flight.

See workflow See pipeline definition What Factory handles

Example workload

2 million hours
  1. Many inputsFiles and HTTPS URLs
  2. Pipeline runsDependencies and retries
  3. Usable resultsFindings for your app
Factory coordinates pipeline runs; your application uses Elements and Rendering to turn selected moments into clips.

One workflow around your models.

Prepare each recording, run your analysis service, and review its timed findings. Factory coordinates the steps; your application decides how to use the results.

One recording

  1. Recording

    Uploaded file or HTTPS URL

  2. Prepare inputs

    TranscriptFrames

    Transcript and frames prepared in parallel

  3. AI analysis

    Your registered HTTPS service

  4. Check the findings

    Your rules and decisions

  5. Use results

    Timed findings for your app

Example workflow: transcription and frame sampling run independently. Your registered HTTPS service waits for both; review follows its findings. Your application reads the results through the API.

Across your library

Run the same workflow across your recordings. Pipeline groups limit runs in flight; endpoint limits control concurrent requests to your service.

Define your processing graph in code.

Name each step and declare what it depends on. Factory validates and versions the definition, executes available work in dependency order and stores results for subsequent steps and your application.

Parallelism
Independent steps can start together.
Your models
Call a registered HTTPS endpoint for custom analysis.
Versioning
Keep a record of the workflow each run used.
Recovery
Inspect attempts and retry failed or cancelled runs.
Pipeline definition reference 
{
  "steps": {
    "transcript": { "type": "transcribe", "with": { "language": "auto" } },
    "frames": { "type": "sample_frames", "with": { "every_ms": 1000 } },
    "analysis": {
      "type": "endpoint",
      "needs": ["transcript", "frames"],
      "with": { "endpoint_id": "00000000-0000-0000-0000-000000000000" }
    },
    "review": { "type": "review", "needs": ["analysis"], "with": { "on_expiry": "reject" } }
  }
}
This example requires a registered HTTPS analysis service. Replace the placeholder endpoint_id; your service supplies the model integration and must return annotations in Factory's result format. Every run in this example waits for review.

Your intelligence. Our video infrastructure.

Keep the models, logic and workflows that make your product unique. Factory provides the execution layer around your registered HTTPS service.

The video infrastructure

Media preparation, versioned workflows, dependency-aware parallel execution, batch scheduling, concurrency controls, retries, run status and review.

Use pipeline groups to manage recordings, with visibility into what completed and what needs attention.

The intelligence and the workflow

Choose your model endpoints, rules, branching logic, quality criteria and downstream results. Start with a few steps or define a more complex graph as you grow.

Your team operates the registered HTTPS service, implements its model integration and keeps its provider credentials. Factory coordinates requests, callbacks and retryable failures.

Endpoint contract

Recovery shouldn't mean starting over.

Some inputs fail and some model endpoints time out. Factory records step attempts, shows what failed and supports retrying failed or cancelled runs. Successful windows keep their results when a run resumes.

Run recovery and limits
Inspect
Find the step or run that failed and understand its state.
Retry
Resume recoverable work rather than recreating the entire workflow manually.
Review
Pause for your team's corrections or approval when a result needs judgment.

Built for video workloads at scale.

Process large libraries

Run the same workflow across collections of recordings, from media preparation through analysis and results.

Scale with incoming work

Manage changes in processing volume with run groups, concurrency controls and visibility into each run.

Deliver usable results

Turn processing results into structured findings, review decisions or inputs for downstream datasets and clips.

Part of the same video stack.

Use Factory on its own or connect it to the rest of Editframe as your application grows.

Connect the source footage

Bring in recordings from uploads and supported existing storage.

Explore Ingestion

Inspect footage and findings

Build an inspection UI for your team or customers.

Explore Playback

Turn findings into clips

Your application passes selected moments to Elements and Rendering for finished video.

Explore Rendering

What does your video pipeline need to do?

Tell us your footage volume, analysis steps and desired outputs. We can help map your workload to Factory and its current capabilities.

Talk to usRead pipeline docs