PenguinHarness

Open-source, local-first multi-agent app development platform
Fully automate building · optimizing · deploying AI applications

1000+ Models · Multi-Platform · Apache 2.0 · Agent Self-Evolution

English | 简体中文

With LangChain, you build agents by hand — at 1× speed.
With PenguinHarness, agents build agents — at 100×.

PenguinHarness runs on your computer or server and automates the agent app lifecycle from creation and evaluation to optimization and deployment. Three reasons define the platform:

A deliberately minimal toolset over clean low-level interfaces: fewer tool calls, fewer tokens — deeply tuned for open models like DeepSeek. Each harness on the model it is normally paired with, same tasks, head-to-head:

Best accuracy on data analysis — at 1/70 of Claude Code's cost.

Describe what you need in one sentence. PenguinHarness builds the complete agent application — scaffold, code, and run instructions, end to end:

Collect the docs from https://github.com/ericbuess/claude-code-docs and build a RAG app that answers Claude Code questions as a configuration expert, citing its sources.

And this is the finished product — a docs expert with retrieval, cited sources that link to the original files, and example questions built in:

And generating this entire RAG app burned just $0.02 (¥0.2) of tokens — on DeepSeek V4 Pro.

With PenguinHarness Skills, an agent evaluates and optimizes itself: run the benchmark, find the lost points, ship version N+1 — with a snapshot before every round and every request observable in the Trace view.

Four plugin categories ship in the box (docs) — skills, plus the session hooks that drive goal mode and continual learning; agents can also write and optimize their own skills:

The desktop app also has a built-in browser in its side dock. Agents drive it with penguin browser and the browser-automation plugin: they read pages, click and type, and pull out data such as your Amazon orders, signed in with the accounts you import from your own browser.

Each family's latest generation only — the app's Models page lists every built-in preset, and any OpenAI-protocol endpoint works too: pick a preset, or point a custom endpoint at any of the 1000+ online and local models.

Start with the desktop app, or install the command line on a workstation or server. Both use the same ~/.penguin/data root and can be mixed freely; a server is also one docker run away:

• 🖥️ Desktop app — a double-click install: it embeds the server and opens already signed in, no terminal involved.
• ⌨️ CLI — a one-line installer (or npm / offline package) puts the penguin command on the machine; penguin web then serves the full Web experience in your browser at http://127.0.0.1:7364 (multi-session chat, agent / skill / model management, usage stats, Trace observability, evaluation center). The online installers bundle their own Node runtime — unpack and run; upgrades and reinstalls never touch your data.

The full Web experience as a standalone application: it embeds the server and opens already signed in — no terminal, no login page, no initial password to copy. It works on the same ~/.penguin/data root as a CLI install, so the two can be used interchangeably (a data root only ever runs one server; if a CLI-started instance is already up, the app attaches to it).

Download the desktop app from the download page. The page serves the OSS-accelerated mirror when it is reachable, and every installer is also attached to each GitHub Release.

The macOS builds are Developer ID signed and notarized, and the Windows installers are Authenticode signed, so neither platform needs a first-launch unblock. Linux is the one exception:

chmod +x penguin-desktop-linux-x86_64.AppImage

curl -fsSL https://penguin.ooo/install.sh | sh
penguin web        # start the service and open http://127.0.0.1:7364

irm https://penguin.ooo/install.ps1 | iex
penguin web        # start the service and open http://127.0.0.1:7364

npm install -g @prismshadow/penguin-cli
penguin web        # start the service and open http://127.0.0.1:7364

docker run -d --name penguin -p 127.0.0.1:7364:7364 -v penguin-data:/data hiyouga/penguinharness:latest
docker logs penguin       # the first-login link, openable as it stands on this machine

The official image runs the same server on 0.0.0.0:7364 with its data root on the /data volume, as an unprivileged user, for linux/amd64 and linux/arm64. It is built from this repository's source: latest is rebuilt on every push to main, and each release is published under its exact version (hiyouga/penguinharness:0.2.13) — there is no moving stable tag. The example publishes the port on the host's loopback, so the Web App answers only on the machine running Docker (http://localhost:7364); to reach it from a network, publish on all interfaces instead (-p 7364:7364), preferably behind a reverse proxy that terminates TLS. Compose file and the full deployment notes — reverse proxies, upgrades, the rescue path — are in the Docker quickstart.

mkdir penguin-install
tar -xzf penguin-linux-x64.tar.gz -C penguin-install
./penguin-install/install.sh

mkdir penguin-install
tar -xzf penguin-darwin-arm64.tar.gz -C penguin-install
./penguin-install/install.sh

Expand-Archive penguin-win32-x64.zip -DestinationPath penguin-install
cd penguin-install
.\install.cmd

The same engine, scriptable — made to be driven by agents (and agents building agents):

penguin config model add --provider deepseek --model-id deepseek-flash --api-key sk-... --set-default
penguin run -m "Create hello.txt containing Hello, Penguin"   # one-shot task
penguin chat       # interactive REPL (/compact, /clear, /exit, Ctrl-C to interrupt)
penguin server     # headless service (same API the Web App uses)

import { createAgent, isCompleteModelMessage, userText } from "@prismshadow/penguin-core";

const agent = await createAgent({ agentId: "default_agent" });
const session = await agent.createSession({ workspaceDir: process.cwd() });

for await (const output of session.run([userText("Create hello.txt containing hi")], {
  approve: async () => "allow", // per-tool-call approval
})) {
  if (isCompleteModelMessage(output) && output.payload.type === "text") {
    console.log(output.payload.text);
  }
}

• Public release of the benchmark suite
• Desktop app
• Windows support
• Agent company and templates
• Company-level self evolving
• OpenShell integration (permission-governed shell)
• More to come…

pnpm install && pnpm build   # build first: core's exports point at dist/
pnpm dev                     # backend + web app together (prefixed logs, deps built once)

See CONTRIBUTING.md for the full workspace guide: dev commands, quality gates, repo layout, and the changelog rule.

Thanks to everyone who has contributed to PenguinHarness!

If you use PenguinHarness in your research, please cite:

@software{penguinharness2026,
  author  = {{PrismShadow Team}},
  title   = {PenguinHarness: Efficient Self-Improving Harness for Everyone},
  year    = {2026},
  url     = {https://github.com/Prism-Shadow/penguin-harness},
  license = {Apache-2.0}
}

This repo benefits from:

• MinGit: the POSIX shell and Git bundled on Windows
• GenericAgent: built-in browser automation

See THIRD-PARTY-NOTICES.md for their licenses.

Apache-2.0 © 2026 Prism Shadow

Built with ❤️ by Yaowei Zheng (author of LlamaFactory), the PrismShadow AI Team, and Fable 5.