Hugging Face PyBot: A Rule-Based Chatbot Built by 1,000 Agents

Hugging Face open-sourced PyBot on November 12, 2026, a rule-based chatbot written in roughly 500,000 lines of Python with no neural weights, built by a swarm of more than 1,000 coding agents across 5,000+ versions. The agents raised PyBot's SmolTalkBench win rate from 0% to 26%, putting it on par with SmolLM-360M-Instruct-era small models, according to the repository README. PyBot ships under Apache-2.0 with about 550,000 lines of tests and runs on Python 3.8+ with no pip dependencies for chat, positioning it as a reproducible artifact for educators and agent builders to inspect which module answered each turn.

Hugging Face open-sourced PyBot on November 12, 2026, a chatbot written in roughly half a million lines of Python with no neural weights, built by a swarm of more than 1,000 agents that iterated thousands of versions until SmolTalkBench win rate reached about 26%. The stunt is not nostalgia for ELIZA . It is an experiment in how much conversational coverage agents can brute-force into explicit rules before you reach for a transformer. For educators and agent builders, PyBot is a reproducible artifact: clone, run, and inspect which module answered each turn. TL;DR | Fact | README claim | |---|---| | Stack | Pure Python 3.8+, no pip dependencies for chat | | Size | ~500k lines bot, ~550k lines tests | | Construction | 1,000+ agents, 5,000+ versions | | Metric | SmolTalkBench win rate 0% to 26% | | Comparison | On par with SmolLM-360M-Instruct era small models | | License | Apache-2.0 | Why Hugging Face built it Modern chatbots run on weights and GPUs . Hugging Face asks a contrarian question in the repository README https://github.com/huggingface/pybot?ref=explainx : if agents can write rules faster than humans once could, how far does a symbolic bot get? The README anchors history with ELIZA , the 1960s pattern matcher that fooled some users with templates, then notes the bottleneck: hand-authored rules do not scale . PyBot replaces the human author with a swarm of coding agents that propose, test, and merge modules. That connects to explainx.ai coverage of agent-written harnesses such as ScoutCode fallbacks https://explainx.ai/blog/scoutcode-agent-harness-free-model-fallbacks-november-2026 , Herdr terminal runtimes https://explainx.ai/blog/herdr-agent-terminal-runtime-coding-agents-github-trending-2026 , and infrarsi recursive training loops https://explainx.ai/blog/infrarsi-recursive-self-improvement-llm-training-harness-2026 . PyBot is the most literal version: the product is the agents' output, not a model they fine-tuned. Repository layout Multiple coding agents delegating tasks toward one shared Python chatbot goal Paths from the README: | Path | Role | Approximate lines | |---|---|---| | bot/modules/ | Turn handlers and arbiter | 67,000 | | bot/understanding/ | Parsing, typos, coreference | 22,000 | | bot/memory/ | Dialogue state | 92,000 | | bot/knowledge/ | World facts as data | 275,000 | | bot/compose/ | Phrasing and fallbacks | 75,000 | | pybot.py | CLI only, no logic | small | | tests/ | unittest suite for CLI | agent-written | Each turn, modules may propose replies; bot/modules/arbiter.py picks the winner. That architecture mirrors multi-candidate routing in larger agent frameworks, except every candidate is hand-generated Python rather than a sampled token. How to run it git clone https://github.com/huggingface/pybot cd pybot python -m pybot The banner ASCII art is part of the charm. Commands: - /reset clears the session - /exit quits - -p "question" for one-shot answers - --seed N for deterministic wording - -v prints which module won and timing Startup takes a few seconds because Python imports hundreds of thousands of lines. Replies take about a second , per README, which is competitive with tiny models on CPU but heavy on disk and RAM. The README also documents pip install . for a global pybot entry point and points to a Hugging Face Space for browser trials with module attribution after each reply, useful when teaching how routing works. SmolTalkBench and what 26% means SmolTalkBench is Hugging Face evaluation where a judge model compares PyBot answers with reference replies. The README says agents raised win rate from 0% to 26% across 5,000 versions , landing near SmolLM-360M-Instruct , a sub-1B instruct model that was frontier-class for its size a few years ago. Twenty-six percent is not competitive with 2026 frontier APIs. The point is cost and inspectability : - No VRAM bill - Every decision traceable to a module file - Tests agents wrote alongside features Teams evaluating when to stop routing and call GPT should treat PyBot as a baseline . If your rules-plus-retrieval stack cannot beat it on your domain, agents may be better spent on data than on more regex. Limits and risks Maintenance: half a million lines is unmaintainable for humans. The project assumes agents , not a staff of editors, own future edits. Generalization: knowledge is lookup tables , not embeddings. Out-of-domain questions fall through to compose fallbacks. Security: pure Python does not eliminate injection tricks; hostile prompts may still reach dangerous eval patterns if any slipped through swarm commits. Audit before exposing PyBot to the public internet. Performance: import time and memory footprint dwarf typical microservices. This is a research demo , not a Lambda deployment template. How it compares to other Hugging Face agent tools PyBot complements neural releases explainx.ai already covered: - Speech-to-speech open agents https://explainx.ai/blog/huggingface-speech-to-speech-voice-agent-guide-2026 need weights. - Tokenizers v1 RC speedups https://explainx.ai/blog/huggingface-tokenizers-v1-rc-30x-faster-2026 accelerate real models PyBot deliberately avoids. - Transformers.js browser scale https://explainx.ai/blog/huggingface-transformers-js-10-million-downloads-browser-ai-2026 shows the opposite trade: tiny models in WASM instead of giant rulesets in CPython. PyBot is the control group in that lineup. Inside the arbiter and module competition Agent harness scaffolding where modules compete and an arbiter picks one reply The README compares each turn to a candidate election . Every module in bot/modules/ may propose an answer with confidence metadata. The arbiter scores proposals using rules that are themselves Python, not learned attention. That design teaches three agent-system lessons without GPUs: 1. Explicit routing beats monolithic prompts when domains are separable billing versus trivia . 2. Arbiters need tests the same way models need evals; PyBot ships 550k lines of agent-authored tests to catch regressions when the swarm edits a module. 3. Debuggability is the payoff: -v mode shows which module won, similar to logging tool calls in OpenAI Codex harnesses https://explainx.ai/blog/openai-codex-amazon-bedrock-sso-agentcore-gateway-setup-guide-2026 but entirely offline. Walk through the README kettle example mentally: user mentions limescale, PyBot answers with vinegar steps; follow-up "how long does that take" routes to a duration snippet; "what is my name" pulls memory store state from the earlier "I am Sam" turn. That chain is stateful symbolic AI , not retrieval augmented generation. ELIZA, SmolLM, and frontier APIs | Approach | Training | Inspectability | Quality band README | |---|---|---|---| | ELIZA templates | None | High | Narrow 1960s demos | | PyBot rules | None | High | ~26% SmolTalkBench | | SmolLM-360M-Instruct | Supervised FT | Medium weights | README parity target | | 2026 frontier chat APIs | RLHF plus tools | Low | Production default | PyBot does not argue you should ship rules to customers. It argues agents can saturate symbolic coverage before you spend tokens, a useful step in shadcn-style skill audits https://explainx.ai/blog/shadcn-improve-agent-skill-audit-expensive-execute-cheap-2026 where cheap executes should run before expensive models. Agent swarm methodology what Hugging Face implies The README states more than 1,000 agents wrote and evaluated over 5,000 versions . Hugging Face does not publish the orchestration harness in the same repo, but the implication for practitioners is clear: - Treat version control as the coordination layer, not chat threads. - Require automatic benchmarks after each merge, here SmolTalkBench win rate. - Accept monotonic growth in lines of code when agents, not humans, pay the typing cost. That rhymes with WorkflowArena multi-agent benchmarks https://explainx.ai/blog/workflowarena-multi-agent-orchestration-benchmark-einsia-2026 and with Raindrop agent memory https://explainx.ai/blog/raindrop-reasoning-agent-memory-tau2-bench-67-percent-2026 research asking how many specialized workers beat one model. PyBot is the extreme where workers literally author separate files. Failure stories to expect when you clone Expect rough edges consistent with agent-generated repos: - Long cold start while CPython imports hundreds of thousands of lines. - Odd edge answers when two modules tie and the arbiter picks arbitrarily without --seed . - Giant git objects that make CI painful unless you sparse-checkout bot/modules slices for class labs. Fork maintainers should add human lint gates before publishing PyBot derivatives as customer-facing bots. Agents scale output; they do not automatically scale judgment. Extending PyBot in your own lab If you assign students or report readers to modify PyBot, start small: 1. Add a module under bot/modules/ that only handles one intent, such as campus dining hours, and register it with the arbiter. 2. Write a unittest that feeds fixed strings and asserts exact replies, matching the repo style in tests/ . 3. Run SmolTalkBench or a homegrown CSV of prompts before and after to see whether win rate moves or collapses. 4. Compare latency with time python -m pybot -p "hello" before and after your edit; accidental imports can balloon cold start. 5. Document which knowledge files you touched in bot/knowledge/ so the next agent or human knows where facts live. That workflow mirrors how professional teams treat skills in Claude Code or Codex without shipping half a million lines to production. PyBot is the didactic version: failures are cheap, stack traces are readable, and you can delete a bad module without retraining. When to still use a real model Use PyBot to calibrate expectations, not to replace: - Open-weight local models when you need offline privacy and can tolerate quant weights, covered in TensorFold Zig inference https://explainx.ai/blog/tensorfold-zig-local-llm-inference-metal-cuda-api-2026 and countless GGUF guides. - Frontier APIs when tasks need multi-step reasoning across tools. - Speech stacks such as ElevenLabs Scribe v3 https://explainx.ai/blog/elevenlabs-scribe-v3-v3-live-speech-to-text-turn-detection-2026 where neural acoustic models still dominate. The Hugging Face README itself positions PyBot beside SmolLM-360M, not beside Claude or GPT. Keep that humility when executives ask whether agents eliminated the need for GPUs. Watch the repository for stars and issues over the next week. Early commits may land documentation fixes as outsiders stress-test import times on laptops without discrete GPUs. Classroom and workshop uses 1. Routing labs: use -v mode to show arbiter decisions live. 2. Benchmark literacy: reproduce SmolTalkBench on a slice and discuss judge-model bias. 3. History bridge: compare ELIZA patterns to bot/understanding engines. 4. Agent ethics: debate whether swarm-generated code needs the same review as human commits. 5. Bitter Lesson discussion: pair with Richard Sutton scaling debate https://explainx.ai/blog/richard-sutton-bitter-lesson-llm-scaling-debate-november-2026 readings. Related reading Primary sources: Hugging Face PyBot repository https://github.com/huggingface/pybot?ref=explainx , README accessed November 12, 2026; SmolTalkBench on Hugging Face https://huggingface.co/spaces/HuggingFaceFW/tools?ref=explainx as referenced in project materials.