Welcome to Clawpy

Clawpy is an open-source Agentic OS and desktop/web control plane for supervised AI work. It brings browser use, computer use, coding, research, media and publishing workflows, marketplace operations, long-term memory, integrations, and human review into one governed operator surface.

The product direction is intentionally human-centred: Clawpy should help agents do more useful work without forcing the operator to trust a black box. A good Clawpy workflow shows what was planned, what ran, what changed, what failed, what needs approval, and what can safely be automated next.

What Clawpy Is For

Clawpy is being built for people who want AI to help run real work across life, code, and business, while keeping accountability visible.

The highest-value workflows are:

Browser use - research, web workflows, account-based tasks, verification, and supervised browsing with clear interruption and approval paths.
Computer use - desktop control, file work, local tools, shell tasks, and app workflows that remain observable to the human.
Coding work - Clawpito reviews, plans, fixes, tests, scores, reports release readiness, and keeps its own modules hygienic.
Research and planning - long-running investigation, synthesis, task breakdown, sprint planning, and operator-friendly summaries.
Business operations - metrics, release notes, active PRs, bugs, onboarding, APIs, database work, guardrails, cost, token, and model reporting.
Media and publishing - content creation, review, routing, scheduling, and publishing workflows with human approval where needed.
Integrations - Telegram, Discord, Slack, marketplace flows, web tools, and external service adapters.
Auditability - decision trails, recovery paths, approval records, readiness checks, and failure reporting.

Current Product Shape

Clawpy is not just a single chat interface. It is a set of coordinated operating lanes:

Alfred operator flow - the calm front door for setup, planning, browser/computer work, follow-up, and human-friendly summaries.
Lucius planning mode - a business and operations partner for turning goals into lanes, milestones, metrics, and review rhythms.
Guardian safety layer - policy checks, approval gates, risk escalation, safety routines, and audit-focused alerts.
Morpheus / Clawpito engineering lane - code review, scoped implementation, validation, PR workflow, hygiene checks, and release-readiness reporting.
Trinity media lane - creative, publishing, audience, and brand workflows.
Oracle research lane - deep research, synthesis, competitive analysis, and long-horizon knowledge work.
Neo review lane - QA, verification, release gates, test evidence, and structured disagreement before risky changes.

These roles are useful because they make responsibility legible. The human should be able to tell who is planning, who is operating, who is reviewing, who is escalating risk, and who needs approval.

Core Concepts

Agentic OS - Clawpy is the control plane where agents, tools, memory, policies, approvals, and runtime services meet.
Human-first interface - the system may be agentic underneath, but the surface should stay simple, calm, and explainable.
Supervised autonomy - agents can work in the background, but sensitive actions move through approval, readiness, policy, and audit boundaries.
Structured memory - Clawpy preserves useful context across sessions with human-readable notes and indexed recall.
Review before trust - important work should produce evidence: logs, tests, screenshots, diffs, readiness reports, or approval records.
Code hygiene as product behavior - the coding workflow should enforce the same architecture discipline that it recommends to the wider codebase.

Clawpito: The Coding Workflow

Clawpito is Clawpy's coding-agent lane. It is designed to help with code review, planning, implementation, tests, release readiness, and post-feature cleanup.

The current Clawpito v6 direction includes:

Dynamic dispatch across review, planning, fixing, validation, scoring, hygiene, memory, Git, and reporting lanes.
Hygiene guards for module budgets, broad exception handling, silent swallows, duplicate runtime mechanics, subprocess ownership, and architecture layering.
Release-readiness reports that combine validation, risk, failure-path coverage, cost, and human approval state.
A human-centred Kanban and planning surface so operators see work, risks, blockers, and progress without being buried in agent internals.
Post-feature cleanup as part of the workflow, not as a heroic manual afterthought.

This matters because an Agentic OS cannot become release-worthy by adding features alone. It also needs small modules, visible failures, typed recovery paths, reviewable PRs, and predictable rollback behavior.

How The Loop Works

Describe the outcome - Start with a plain-language goal in the operator console, planning room, CLI, or an integration channel.
Plan the work - Alfred and Lucius help split the goal into lanes, risks, approval points, and success criteria.
Run the right tools - Clawpy delegates to browser mode, desktop control, coding, media, publishing, memory, marketplace, or integration services.
Verify the result - Tests, screenshots, readiness reports, Guardian checks, and human review decide whether work can continue.
Record what happened - Clawpy keeps the decision trail, useful artifacts, failure notes, and reusable patterns.
Improve the next run - The system should learn from repeated workflows while keeping the human in control of what becomes automated.

Safety And Accountability

The long-term goal is meaningful autonomy with human accountability, not hidden automation.

Clawpy should make it clear:

Which agent or lane took an action.
Which tools were used.
Which files, accounts, or services were touched.
Which risks were detected.
Which actions needed approval.
Which failures were recovered from.
Which failures still need human attention.

When something goes wrong, the system should surface the failure clearly rather than swallowing it silently. That principle applies to user workflows and to Clawpy's own codebase.

Self-Hosted First

Clawpy is open source and self-hostable. Operators should be able to control their code, data, agent profiles, model keys, secrets, and runtime boundaries.

Managed or hosted offerings may layer on top later, but the core project is designed so serious users can run and inspect it themselves.

Get Started

Start with the Quickstart, then read Why Clawpy for the operating model and safety philosophy.