Open source Apache 2.0 YAML flows Python 3.12+

Automate with flows,
not loose prompts Chain LLM, shell, and code in one YAML pipeline

Telize is a flow runner for agentic automation: one YAML file defines your flows and steps — shell, files, LLM, Python, nested flows — validated before execution, with live progress in your terminal.

Install Telize View on GitHub
pip install telize
workflow.yaml 
models:
  default:
    model: qwen3.5:4b
    api_url: http://localhost:11434

flows:
  main:
    steps:
      - name: fetch
        uses: shell
        run: |
          cd /path/to/data
          cat ./data.txt
      - name: summarize
        uses: llm
        model: default
        prompt: |
          Summarize:
          {{ steps.fetch.output }}
        output_to: /path/to/data/summary.md
$ telize -f workflow.yaml
✓ fetch — 0.1s
✓ summarize — 2.4s
"Three key points from the data…"
6 Step types in a flow
YAML Flows in one YAML file
Local Ollama-ready by default
Rich Live flow progress in the CLI

Features

Everything you need to run flows end-to-end

Compose agentic automation as explicit flows—without giving up your stack, data, or models.

YAML workflows

One YAML file defines config, named models, flows, and steps. Version control friendly and easy to review.

Steps inside a flow

Mix input, llm, shell, python, flow, and yaml actions in any pipeline.

Jinja templating

Wire step outputs together with {{ steps.name.output }} and environment variables at load time.

Loops & sub-flows

Split lists, repeat steps, call sub-flows—flows composing flows with loop and nested uses: flow.

Validated upfront

Pydantic models catch schema errors before any step runs. Use --validate-only in CI.

Rich CLI output

Progress bars, step panels, and clear errors—built on Rich for a polished terminal experience.

How flows run

From YAML flow to finished run

Load a flow definition, validate it, then execute steps in order—with loops and sub-flows when you need them.

  1. Telize loads your YAML and validates it against typed Pydantic models.
  2. The flow named in config.entrypoint runs first.
  3. Each step executes through a registered action handler.
  4. Later steps reference earlier outputs via Jinja templates.
  5. The CLI prints progress and results as the flow runs.

Get started

Installation

Python 3.12+ required. Pull a model for agentic (llm) steps—Ollama or compatible API.

PyPI 
pip install telize
From source 
git clone https://github.com/telize-ai/telize.git
cd telize
uv sync
uv pip install -e .
Verify 
telize --version

Run your first flow in 3 steps

1

Start Ollama & pull a model

ollama pull qwen3.5:4b
2

Define a flow in hello.yaml

config:
  entrypoint: main

models:
  default:
    provider: openai
    model: qwen3.5:4b
    api_url: http://localhost:11434

flows:
  main:
    steps:
      - name: greet
        uses: llm
        model: default
        prompt: Say hello in one friendly sentence.
3

Run it

telize -f hello.yaml

Validate without running: telize -f hello.yaml --validate-only

Documentation

Flow & step reference

YAML schema for config, models, and flows at a glance. Full details in the README.

Top-level keys

KeyDescription
configGlobal settings: entrypoint (which flow runs first)
modelsNamed LLM profiles: provider, model, temperature, api_url, optional api_key and system_prompt
flowsNamed flows; config.entrypoint must match one key

Step actions (uses)

usesDescription
inputRead a file or directory (with glob include)
llmSend a prompt using a named model from models; optional output_to, loop
shellRun run commands; optional envs (supports templates)
pythonCall call (module.function) with args
flowRun another flow via run
yamlRun an external workflow from file (own models and config); optional input map for the child

Templating

Load time

{{ env.VAR }} — expanded when the file is parsed

Runtime

{{ steps.<name>.output }}, {{ models.<name>.model }}, {{ input.<key> }}, {{ item }} in loops

Wire a shell step into an agentic LLM step 
- name: fetch_data
  uses: shell
  run: cat ./data.txt

- name: summarize
  uses: llm
  model: default
  prompt: |
    Summarize this:
    {{ steps.fetch_data.output }}

CLI

usage: telize [-h] [--version] [-f FILE] [--validate-only]

options:
  -h, --help         show help
  --version          show version
  -f, --file FILE    path to workflow YAML
  --validate-only    parse and validate without running steps

Examples

Example flows (YAML)

Clone the repo and run bundled flow files from the project root.

minimal_llm.yaml

Minimal flow: one LLM step with a default model profile.

telize -f examples/minimal_llm.yaml

shell_to_llm.yaml

Chain shell output into an LLM prompt with Jinja templates.

telize -f examples/shell_to_llm.yaml

llm_loop.yaml

Run an LLM step per item using loop and split_by.

telize -f examples/llm_loop.yaml

read_directory.yaml

Read files from a directory with input, then summarize with an LLM step.

telize -f examples/read_directory.yaml

Requirements

What you need

  • Python 3.12+ — typed, modern runtime
  • Ollama or compatible API for agentic steps (uses: llm) — set api_url on each model (default http://localhost:11434)
  • uv — optional, recommended for development

Community

Contributing

Bug reports, documentation, and pull requests are welcome.

Contributing guide

PR guidelines, development setup, and code standards.

Issues

Report bugs or discuss features before large changes.

CI status

Automated tests on every push—pytest, ruff, mypy.

Changelog

Release notes and version history.

Development commands

uv sync
uv run pytest
uv run ruff check .
uv run ruff format .
uv run mypy

Ready to run your first flow?

Install Telize, point it at a YAML flow file, and automate with LLM, shell, and code—on your machine.

Get started PyPI