kdeps workflow
A deterministic YAML pipeline. Serve it as an HTTP API, a bot, or a file processor. The same input always runs the same steps in the same order.
Build a workflow
Build git-native AI appliances
Your agent is YAML in your repository. You review it as a pull request. kdeps ships it with an open-source model to machines that you control: cloud, on-prem, edge, or air-gapped.
$ kdeps
kdeps v3 | agent loop
Model: llama3.2 (llamafile, offline) | /help for commands
> find the failing tests in ./api and suggest a fix
Ran go test ./api/... - 2 failures in handler_test.go.
Both assert 200, but the router now returns 204 for an
empty body. Update the expected status on lines 41 and 58.
> /model claude-sonnet
Switched to claude-sonnet (Anthropic)
>who it's for
kdeps packages the model with the workflow. As a result, all of it runs in your boundary.
Deploy an internal RAG or document agent fully in the VPC of your customer. No prompts, documents, or embeddings go out of their infrastructure.
on-prem · regulatedShip the model and workflow as a bootable ISO or one binary. It runs on a disconnected edge device. It needs no external AI service and no network at inference time.
edge · offlineChange a YAML workflow into a production HTTP API and container. You do not need FastAPI, LangChain code, or a Dockerfile that you write manually. You declare the validation, the order, and the response shape.
workflow modeWorking examples. Each example is a project that you can run:
git-native
The YAML in your repository fully defines what the appliance does: the model, the validation, the step order, and the response shape. When you change the YAML and commit it, the behavior changes. Your git history is the changelog of the agent behavior. Only the model binding is outside the repository. As a result, the same commit runs with a local model on a laptop and with a cloud model in production.
validations:
check:
- get('q') != ''
+ - len(get('q')) < 2000 # reject prompts over 2000 characters
chat:
model:
- name: llama3.2:1b
+ name: qwen2.5:7b
context:
prompt: "{{ get('q') }}"One commit makes two behavior changes: a larger model, and a 400 error for input that is too large. You do not change a deploy configuration or a console setting. The diff is the change.
A change to an agent is a diff: a new resource, a stricter validation, or a different response shape. Review it in a pull request, as you review all other code.
A git tag is a release. kdeps validate and kdeps bundle build run on all checkouts and tags. The built appliance also pins the runtime and the model.
In CI, check out a tag, run kdeps validate and kdeps bundle build, and push the image. The same commit always makes the same appliance.
With the registry, you can install and publish agents by name. kdeps install owner/repo pulls from a GitHub repository. You do not need the registry to build or deploy your own agent.
getting started
Write YAML. Run it. Ship the same file.
Declare resources: chat, HTTP, Python, SQL. Connect them with requires: under flow:. One file operates in both modes.
kdeps run serves the API. kdeps . loads the same pipeline as a tool in the REPL.
Export it as Docker, Kubernetes, ISO, or a binary. All use the same workflow.yaml. You do not rewrite or reconfigure it.
compared to manual code
You do not write Python scripts, connection code, or boilerplate.
| Traditional approach | kdeps |
|---|---|
| Python script + Flask + OpenAI SDK + retry logic | One workflow.yaml file |
| Dependency code that you write manually | flow.requires: in YAML |
| Error handling that you write manually | onError: block (continue / retry / fail) |
| A Dockerfile and a CI pipeline for deployment | kdeps bundle build --tag then docker push |
| Agent chains that you write manually | agent: resource. One agent calls a different agent declaratively |
book
From your first agent to production deployment, in one book.
Build & Deploy Autonomous AI Agents and Agencies in YAML
Your AI prototype works. Now ship it. This practical guide covers deterministic pipelines, multi-agent orchestration, error handling, and vendor-agnostic deployment. Most AI frameworks leave these production problems to you.
Read the book ->