DEV Community: Jaroslaw Nowosad

Meet Kowalski

Jaroslaw Nowosad — Sun, 25 Oct 2026 15:33:11 +0000

October 2026

This post first appeared on the Kowalski blog. It's written for people who have never heard of Kowalski, so let's start at the beginning.

Kowalski is a small team of AI agents that lives on your own computer and does chores for you. Not a chatbot you have to keep talking to, and not a platform you have to administer. You hand it a job, it does the job, and you get a file back. It's open source (MIT), written in Rust, and it runs on a free local model through Ollama, or on any hosted model with your own key.

There are two well-known open-source projects in the same neighbourhood, and they help to explain what Kowalski is by what it isn't. OpenClaw is a personal assistant you chat with: it gets wide access to your machine and your apps, and it works best with a big frontier model behind it. Paperclip goes one level up: it runs a whole "company" of paid coding agents, with org charts, budgets and approvals. Both are impressive. Kowalski makes the opposite bet. Each job is a small, fixed pipeline you can read. The agents only touch the one folder you give them, and they ask before doing anything risky. The hard parts (fetching pages, running SQL, building spreadsheets) are ordinary code, so a small free model on a laptop is enough. The result is cheaper (€0 a run on a local model), more private (nothing leaves your machine), and easier to trust (every number comes from a query, not from the model's imagination). Penguins: no lobsters, no corporation.

So what do you actually give it? A chore: a question about a spreadsheet, the five pages you read every morning, a document that just landed in your inbox, a topic to research. Kowalski hands the chore to a horde, a short pipeline of specialised agents we call penguins, and gives you back something you can use: a report workbook, a one-page brief, a note in your Obsidian vault.

What it does today

Five hordes come with it:h

Spreadsheet analyst. Ask questions about your workbooks in plain words and get a report workbook back. The model writes the SQL; every number comes from a query engine, never from the model.
Morning brief. The pages you follow, read for you: the few items worth your time, why each matters to you, and the link. It can run every weekday at 7:00.
Folder watcher. Drop a document into its inbox and get a note: what it is, the key facts, and what to do by when.
Knowledge compiler. Ask a question and list the pages that should answer it. You get one note with its sources, saved straight into your Obsidian vault.
URL summarizer. A list of links in, a short summary of each out.

A horde is a folder of plain Markdown files, so you can read exactly what each penguin is told, copy one and change it, or have kowalski build a new one with you.

How it got here

Kowalski started on 4 March 2025 as a weekend experiment: a Rust program that could talk to a local Ollama model. Here's the short version of what happened next.

2025: big plans. By the summer it had a five-layer architecture, a crate per agent, three databases and a federation layer for a distributed system nobody was running. It was a good exercise and a bad product: nothing in it could be handed to someone who doesn't write Rust.
Early 2026: smaller. 1.0 deleted most of that on purpose. One agent type instead of many crates, SQLite instead of three databases, an HTTP server and a web UI, and tools reached through MCP.
Spring 2026: hordes. The idea that gave the project its shape: a pipeline as a folder of Markdown. Builders, graphs with loops, then triggers (cron, file watch, webhook) and durable runs that survive a restart.
September 2026: the product. One binary with the UI inside, a three-question Setup, ready-made hordes, and data steps that keep numbers out of the model. Since 2.5: a signed Mac app you install by dragging it to Applications.

Eighteen months and more than 700 commits later, the pattern is clear: almost every good change removed something. The long version of that story is Eighteen months of Kowalski.

Who it's for

People with recurring chores and data they'd rather keep on their own machine: a small business owner with a sales workbook, an engineer who reads the same five sites every morning, a researcher whose notes live in Obsidian. If you write code, a horde is a folder you can version, review and share.

Try it

On a Mac, download Kowalski.dmg, drag it to Applications and open it. On a Mac or Linux, from a terminal:

curl -fsSL https://raw.githubusercontent.com/yarenty/kowalski/main/install.sh | bash
kowalski

Your browser opens on Setup: pick a model, a folder, and optionally your tableski account. Then pick a horde and send it in. Everything is at github.com/yarenty/kowalski.

If something goes wrong, open an issue. Kowalski does the analysis; I do the apologising. And if everything works first time, just smile and wave, boys. Smile and wave. 🐧

Originally published on the Kowalski blog.

Kowalski: The Rust-native Agentic AI Framework

Jaroslaw Nowosad — Mon, 30 Jun 2025 16:19:05 +0000

Kowalski: The Rust-native Agentic AI Framework

I’m excited to share the latest milestone for Kowalski—a powerful, modular agentic AI framework built in Rust for local-first, extensible LLM workflows. Three months ago, I released Kowalski v0.2.0, a major stepping stone, where I start playing with different tools. Today, the codebase has evolved dramatically, with v0.5.0 rolling out extensive refactoring, architectural improvements, and a wealth of new functionality ;-).

TL;DR: Kowalski v0.5.0 brings deep refactoring, modular architecture, multi-agent orchestration, and robust docs across submodules. If you care about Rust, AI agents, and extensible tooling, now’s the time to jump in and build together!

A Deep Dive into v0.5.0

Since v0.2.0, the Kowalski ecosystem has undergone:

Massive refactoring of core abstractions and crate structure:
The kowalski-core, kowalski-tools, and agent-specific crates (academic, code, data, web) have each been reorganized into clean, self-contained modules with dedicated README.md files, detailing usage, examples, and extension points ([github.com/yarenty/kowalski][1]).
New federation layer for multi-agent orchestration:
The emerging kowalski-federation crate introduces a flexible registry and task-passing layers, enabling future multi-agent workflows and scalable core collaboration.
Improved CLI & agent-specific binaries:
Each agent—academic, code, data, web—comes with its own improved CLI and documentation. The kowalski-cli now supports seamless interaction across all binaries, with better streaming, configurable prompts, and embedded tool sets.
Enhanced pluggable tools:
The kowalski-tools crate now offers more granular support for CSV analysis, multi-language code analysis (Rust, Python, Java), web scraping, PDF/document parsing, and dynamic prompt strategies—each documented in submodule README.md files ([github.com][1]).
Rust API stability:
The core API, based on the BaseAgent, now supports typed configs, async multi-tool support, and more robust error handling, making embedding into larger Rust stacks smoother and more reliable.

Why Kowalski v0.5.0 Matters

Rust lovers and AI developers, here’s why this release stands out:

Full-stack Rust agentic workflows
With zero Python dependencies, Kowalski compiles into performant, standalone binaries. Whether launching kowalski-code-agent for code reviews or embedding agents via the Rust API, you’re operating at native speed.

Modular by design
Each submodule is self-documented and self-contained, lowering the barrier for new contributors. Want to create a PDFPresentationAgent or integrate telemetry? Just read the README in the existing agent templates and go.

Streamlined CLI experience
The unified CLI gives consistent interfaces across agents. Under the hood, agents share core abstractions, so switching from data analysis to web scraping is seamless.

Future-proof federation support
The new federation crate opens the door to lightweight orchestrated, multi-agent workflows—think pipeline automations, task delegation, and agent-to-agent communication.

Get Involved: Let’s Shape Agentic Rust Together

Here’s how you can partner with the project:

Extend the toolset: add new agents (e.g., document-summaries, intent-classification), implement new tools, or polish existing ones.
Improve federation workflows: help standardize protocols, design multi-agent orchestration logic, data passing, and telemetry.
Embed Kowalski in Rust services: build bots, backend services, UI apps that leverage Kowalski agents for intelligent behavior.
Document and promote: each submodule already includes README files—help expand examples, write blog posts, or record demos.
Contribute core enhancements: testing, error handling, performance improvements in the core or tools crates.

Start Using v0.5.0 Today

Clone the repo:

   git clone https://github.com/yarenty/kowalski.git
   cd kowalski

Browse submodules & READMEs: Each agent and tool lives in its own folder with clear instructions.
Build & run:

   cargo build --release

Run agents:

   ollama serve &
   ollama pull llama3.2
   ./target/release/kowalski-cli chat "Hey Kowalski, what's up?"
   ./target/release/kowalski-code-agent --file src/main.rs

Embed in Rust:

   use kowalski_core::{Config, BaseAgent};
   let mut agent = BaseAgent::new(Config::default(), "Demo", "Agent v0.5.0").await?;
   let conv = agent.start_conversation("llama3.2");
   agent.add_message(&conv, "user", "Summarize this code module").await?;

Let’s Connect & Collaborate

If you’re as passionate about Agentic AI and Rust as I am, let’s talk 🚀. Whether you’d like to:

Build new agents or tool integrations,
Architect fully orchestrated agent systems,
Demo Kowalski in your workflows,
Co-author articles or demos in the Rust+AI space—

I’m ready to brainstorm on a call, pair on code, or publish together. Reach out via GitHub issues, PRs, or drop me a message to get started.

[1]: https://github.com/yarenty/kowalski" yarenty/kowalski: High performance Rust based AI Agent framework.- GitHub"