Tiny Claw (Mandibles)
A lightweight autonomous personal AI companion: tiny plugin-based core, self-improving memory, and smart cost-tiering routing that make AI simple, affordable, and truly personal.
Trust: source_attribution earns full marks — the README Credits section thoroughly lists OpenClaw, SHIELD.md, Bun, and WG Tech Labs components, and explicitly disclaims any crypto-token affiliation. dependency_security gets 2: all GitHub Actions are SHA-pinned, weekly CodeQL scanning is enabled, and undici is overridden in package.. least_privilege, user_confirmation, sensitive_data_handling, and rollback score only 1: the README claims a path sandbox, permission engine, AES-256-GCM secrets management, and auto-backup, but none of these implementations appear in the supplied source; as static assertions without support they cannot be credited. data_flow_transparency and external_effects get 1: the agent can execute shell commands and reach cloud LLMs (Ollama Cloud), yet no user-visible statement of outbound data scope was found. No malware or red-line behavior was identified.
Reliability: self_consistency 2 — the README architecture matches the package. workspaces and directory tree; deducted because version 2.0.0 coexists with an explicit 'things will break' warning, a positioning contradiction. dependency_availability 2 — CI uses --frozen-lockfile with a pinned Bun setup, supporting reproducible builds; deducted for no degradation guidance for external services like Ollama Cloud. failure_messages 2 — compactor tests explicitly verify graceful null return on provider failure; but error handling for high-risk paths (shell, sandbox) has no evidence.
Adaptability: audience_and_scenarios 3 — the README clearly targets personal (not enterprise) users with a comparison table, philosophy section, and explicit scenario framing. capability_boundaries 2 — the non-overridable personality and pre-release status are stated; deducted because per-subsystem limits are undocumented. trigger_precision 1 — the 8-dimension classifier and smart routing appear only in marketing tables with no code or test corroboration of accuracy. environment_fit 2 — Bun-native, SQLite persistence, and zero-config self-setup are clear; deducted because Quick Start omits the Bun prerequisite.
Convention: information_architecture 3 — the project structure is annotated per directory with clear package responsibilities. license 3 — full GPL-3.0 text ships in-repo and matches README and package. declarations. known_limitations 2 — an explicit warning that the project is in heavy development and should not be run yet is honest; deducted for lack of subsystem-level known-issue lists. install_notes 1 — only two commands with no prerequisites or troubleshooting. naming_stability 2 — the project explicitly distinguishes itself from OpenClaw and explains its naming, but at 2.0.0 with no API stability commitment. examples_and_faq 1 — a single channel-plugin guide link, no usage examples. versioning_changelog 1 — no changelog present. maintenance_responsibility 2 — identifiable single author, issue-template guidance, and CI gates; deducted for unaddressed single-maintainer sustainability risk.
Effectiveness: output_usability 2 — dual CLI/web entry points with a concretely described Svelte 5 SSE UI; deducted because no source of the actual experience is provided. marginal_value 2 — 'built from scratch, plugin architecture, bundled free Ollama Cloud' is a clear differentiation; deducted because the comparison table is self-declared. cost_benefit 2 — tiered routing and 4-layer compaction target cost, with compression-statistics tests corroborating part of it; deducted because savings lack baseline data and the project itself says running it now may spoil the experience, making present-day benefit doubtful.
Verifiability: claim_traceability 1 — the README makes many quantitative/technical claims (8-dim classifier, 5-layer security, 3-layer memory), but the supplied source covers only the compactor subsystem; most claims cannot be traced in this review, and the coverage imbalance is the deduction reason. cross_source_corroboration 2 — the compactor tests do corroborate the '4-layer pipeline, tiered summaries, metrics' claims, and package./CI agree with the README structure; other subsystems lack a second source. fact_inference_separation 2 — the README uses NOTE/WARNING/CAUTION blocks to separate facts from forward-looking plans with generally measured wording; deducted because the comparison table presents inferential advantages as established facts.
- The project self-describes as under heavy development with 'things will break' and officially recommends waiting for the first release — this static review is not a usability endorsement.
- Security claims (sandbox, permission engine, SHIELD.md enforcement, AES-256-GCM secrets management) are unverifiable from the supplied source; do not assume actual protections exist.
- The agent can execute shell commands and communicate with cloud LLMs; audit outbound data scope and key management yourself before deploying.
- Quick Start omits the Bun runtime prerequisite, so installation may fail as documented.
- Most core claims (8-dim routing, 5-layer security, sub-agent delegation) lack code-level corroboration and should be re-evaluated at first official release.
What does this agent do, and when should you use it?
Tiny Claw (codename Mandibles, the ant) is an autonomous personal AI companion framework by Waren Gonzaga, explicitly an independent alternative to OpenClaw rather than a smaller version of it. It runs natively on the Bun runtime with a deliberately tiny core, while channels, LLM providers, and tools are all plugins, organized into roughly 20 focused packages (core, memory, router, compactor, heartware, delegation, shield, sandbox, etc.). It ships a 3-layer adaptive memory (episodic, semantic FTS5, temporal decay), a 4-layer context compaction pipeline, an 8-dimension query classifier for cost-tiering smart routing, and a runtime SHIELD.md anti-malware enforcement engine. Ollama Cloud is the built-in provider (kimi-k2.5:cloud and gpt-oss:120b-cloud models), and it includes a Discord-style Svelte 5 web UI with real-time SSE streaming. The project is under heavy active development, warns that things will break, and states it has no crypto token.
After bun install && bun start, Tiny Claw launches locally at http://localhost:3000 and walks you through setup conversationally — no config files needed. It self-configures through conversation, learns via the 3-layer memory system in packages/memory (episodic memory + SQLite FTS5 full-text search + temporal decay), and routes requests through the 8-dimension query classifier in packages/router, tiering queries across installed provider plugins (built-in Ollama Cloud, with OpenAI and Anthropic provider plugins supporting automatic failover). packages/compactor compresses context via rule-based pre-compression, shingle deduplication, LLM summarization, and tiered L0/L1/L2 summaries; packages/delegation orchestrates sub-agents with blackboard collaboration and adaptive timeouts; packages/intercom provides pub/sub inter-agent messaging. Security is enforced at runtime by packages/shield (SHIELD.md threat parsing and pattern matching) plus a 5-layer stack: path sandbox, content validation, audit log, auto-backup, and rate limiting.
- Individuals who want a friend-like AI companion with its own personality that grows over time, in the spirit of Codsworth from Fallout
- Cost-sensitive developers and power users who want simple queries routed to cheap models and powerful models reserved for hard tasks
- Non-technical users who want an agent that configures itself through conversation instead of editing config files
- Automation scenarios needing autonomous sub-agent orchestration with blackboard collaboration and event-bus communication
- Users who already have OpenAI or Anthropic API access and want to plug their own accounts in via provider plugins
- Privacy-conscious users who prefer self-hosting with a local Discord-style web UI
What are this agent's strengths and limitations?
- Genuinely native framework built from scratch with zero dependency on external AI frameworks; the core stays tiny and non-monolithic
- 3-layer adaptive memory (episodic, FTS5, temporal decay) plus 4-layer context compaction meaningfully cuts long-term token costs
- 8-dimension smart routing tiers queries by complexity and adapts to whichever provider plugins are installed
- Built-in SHIELD.md anti-malware enforcement plus 5-layer security (path sandbox, content validation, audit log, auto-backup, rate limiting)
- Free Ollama Cloud built in — no Claude Pro/Max subscription needed to get started
- Ships a Discord-like web UI, delegation system, and inter-agent pub/sub communication out of the box
- Under heavy active development with official warnings that things will break; no first official release yet
- Hard dependency on the Bun runtime, not the Node.js 22 + pnpm ecosystem, so integration or migration requires adaptation
- No official crypto token exists — any token using the Tiny Claw name is unaffiliated, so beware impostors
- Its Heartware personality cannot be overridden, making it a poor fit if you need fully configurable system prompts
- Only Ollama Cloud works out of the box; OpenAI/Anthropic require installing provider plugins
How do you install or deploy this agent?
Prerequisites: install the Bun runtime and create a free Ollama Cloud account (the built-in default provider). Steps: clone the repository and run bun install. The project is under heavy development and the authors warn that running it now may spoil the experience — waiting for the first official release is recommended.
How do you use this agent?
Run bun start in the project directory and open http://localhost:3000; Tiny Claw walks you through the rest with no config files. During setup choose between kimi-k2.5:cloud (default) and gpt-oss:120b-cloud, and switch models anytime via conversation. Development: bun dev (hot reload); build: bun build; test: bun test. Channels and providers are plugins — see plugins/channel/README.md for plugin development.
How does this agent compare with similar options?
The README contrasts Tiny Claw with other AI agent frameworks (frameworks built on Pi, Claude Code, or Codex, and OpenClaw): Tiny Claw is a native framework built from scratch with a tiny plugin-based core, self-improving memory, tiered routing, a bundled web UI, and SHIELD.md security, whereas OpenClaw is its inspiration (lobster vs ant) and competing frameworks typically wrap existing frameworks, grow into large monoliths, hit the most expensive model on every query, and require Claude Pro/Max subscriptions or multiple API keys.