Skip to content
Make kdeps YAML with Claude Code, Cursor, or Grok

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 --agent-loop kdeps v3  |  agent loopModel: 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 anempty body. Update the expected status on lines 41 and 58. > /model claude-sonnetSwitched to claude-sonnet (Anthropic) >
$export KDEPS_API_AUTH_TOKEN=dev-token
$kdeps run .
Starting HTTP server on 0.0.0.0:16395
 
$curl -s -X POST localhost:16395/api/v1/chat \
-H "Authorization: Bearer $KDEPS_API_AUTH_TOKEN" \
-H "Content-Type: application/json" \
-d '{"q": "What is entropy, in one sentence?"}'
 
{"success": true, "data": {"answer": "Entropy measures how many microscopic arrangements are consistent with a system's macroscopic state."}}
$

runs on

OllamallamafileOpenAIAnthropicGoogleOpenRouterGroqMistralDeepSeekxAICohereTogetherPerplexityHugging FaceCloudflareBedrockwatsonx

inside kdeps

What one YAML file gives you

Each box is something you get without writing glue code.

One file, any input

kdeps runs it. Requests come from an API, a bot, a file or an interactive prompt.

An agent with tools

A chat with loop: reads, edits and runs commands through the tools you list.

Any model, any time

Name a model per chat or let model: auto pick one. Switch mid-session with /model.

Judges, when you want them

Opt in with judges: auto: a panel reviews the answer and sends it back for a revision on a reject.

Runs offline

llamafile runs the model on your machine. No API key, no data leaves it.

Ship it anywhere

Export the same workflow as a Docker image, Kubernetes manifests, an ISO or one binary.

git-native

The YAML is the behavior spec

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.

git show HEAD — resources/llm.yaml
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.

Reviewable

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.

Versioned

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.

Reproducible

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.

Shareable (optional)

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

How it works

Write YAML. Run it. Ship the same file.

01

Write YAML

Declare resources: chat, HTTP, Python, SQL. Connect them with requires: under flow:. A chat with loop: is an agent.

→
02

Run it

kdeps runs ./workflow.yaml: as an API, a bot, a file processor or an interactive prompt.

→
03

Ship it

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

YAML replaces glue code

You do not write Python scripts, connection code, or boilerplate.

Traditional approachkdeps
Python script + Flask + OpenAI SDK + retry logicOne workflow.yaml file
Dependency code that you write manuallyflow.requires: in YAML
Error handling that you write manuallyonError: block (continue / retry / fail)
A Dockerfile and a CI pipeline for deploymentkdeps bundle build --tag then docker push
Agent chains that you write manuallyagent: resource. One agent calls a different agent declaratively

kdeps has the Apache 2.0 License.