# Show HN: Kdeps – A New CLI Coding Agent That Runs on Open Weight Models

> Source: <https://kdeps.com>
> Published: 2026-07-28 06:11:14+00:00

## Local AI agent

Run `kdeps` and you are in an AI REPL. Use Ollama or llamafile for a fully offline, private coding agent - no API key, no cloud dependency.

Run AI workflows locally. Or deploy them anywhere.

Install kdeps, run `kdeps`, get an AI agent - no API key needed with Ollama or llamafile. Build your workflow in YAML. Deploy as Docker, Kubernetes, or a single binary when you're ready. Proud member of the NVIDIA Inception program.

``` bash
$ kdeps

kdeps v2.x.x  |  Local agent mode
Model: llama3.2 (Ollama)  |  Type /help for commands

> write a Go function that parses a CSV file

Sure. Here's an idiomatic Go CSV parser...

func ParseCSV(r io.Reader) ([][]string, error) {
    reader := csv.NewReader(r)
    return reader.ReadAll()
}

> /model claude-opus-4-8
Switched to claude-opus-4-8 (Anthropic)

>
```

getting started

Three steps from idea to running AI API.

Declare resources -- chat, HTTP, Python, SQL, shell. Wire them with `requires:`

. No glue code.

`kdeps run workflow.yaml`

starts the API server. `kdeps serve`

starts the autonomous agent loop.

POST to your route, get back structured JSON. Export as Docker, Kubernetes, ISO, or a single binary.

platform agnostic

Switch backends in config. No code changes, no lock-in.

run modes

Workflows, agents, and agencies — all from the same YAML.

Resources run in DAG order defined by `requires:`

. Every request takes the same path. Predictable, auditable, ships to production.

Run `kdeps`

for an instant AI REPL - fully offline with llamafile or Ollama, no API key needed. Load workflows as tools: the LLM decides what to call and when.

One agent calls another via the `agent:`

resource type. Compose agents like functions — each runs independently, results flow back.

why kdeps

No Python scripts, no wiring, no boilerplate.

| Traditional approach | kdeps |
|---|---|
| Python script + Flask + OpenAI SDK + retry logic | One `workflow.yaml` file |
| Manual dependency wiring | `requires:` in YAML |
| Write error handling by hand | `onError:` block (continue / retry / fail) |
| Write Dockerfile + CI pipeline for deployment | `kdeps bundle build --tag` then `docker push` |
| Glue code between services | Resources pass data via `output()` |
| Manual polling loop for bots | `input.sources: [bot]` in workflow config |
| Chaining agents by hand | `agent:` resource — one agent calls another declaratively |

registry

Install pre-built packages from the registry. Publish your own.

Reusable capability extensions. Install with one command, invoke with `component:`

and typed inputs.

Complete DAG pipelines packaged as `.kdeps`

archives. Drop them into an agency or run them standalone.

Multi-agent orchestration bundles packaged as `.kagency`

archives. One entry point, many agents.

examples

Real patterns from the examples directory. Every one is a working workflow.

POST a JSON body, run a DAG pipeline, get structured JSON back. The default pattern for workflow mode.

workflow modePoll for messages, run a multi-step pipeline, reply with LLM responses. Two resources: llm and reply.

workflow modeRead from stdin, call an LLM, write to stdout. One-shot. Perfect for cron jobs and CI pipelines.

workflow modeIndex documents locally, search with keywords, feed results into an LLM prompt. Fully on-prem.

workflow modeOrchestrate multiple agents. One summarises, another translates — each an independent workflow.

multi-agentbook

Everything from first agent to production deployment, in one place.

Build & Deploy Autonomous AI Agents and Agencies in YAML

Your AI prototype works. Now ship it. Hands-on guide to deterministic pipelines, multi-agent orchestration, error handling, and vendor-agnostic deployment — the production challenges most AI frameworks leave to you.

Read the book ->