Skip to content

guanbear/PraxisBase

BranchesTags

Repository files navigation

PraxisBase — Agent-Native Knowledge Substrate

PraxisBase — Agent-Native Knowledge Substrate

Languages: English | 简体中文

AGENT-NATIVE KNOWLEDGE SUBSTRATE

Disposable Agents. Durable Experience.

中文：知行未必一，经验自成基。

PraxisBase is an agent-native knowledge substrate for people and teams running many temporary and persistent agents. It keeps the agents disposable while making their experience durable: knowledge, repair memory, reusable skills, decisions, and preferences.

The project started from the LLM Wiki idea, but its current direction is broader: agents are cattle, knowledge is the herd memory. Codex, Claude Code, OpenCode, Hermes, OpenHuman, OpenClaw, temporary repair agents, and future MCP clients should all be replaceable peers that read and write the same durable experience layer through a common CLI and file protocol.

Core Philosophy

Modern agent systems should not depend on one precious long-lived container or one hand-tended agent session. Inspired by Anthropic's Managed Agents architecture, PraxisBase separates:

  • Brains: temporary or persistent agent loops that reason and decide
  • Hands: sandboxes, tools, shells, OpenClaw environments, K8s systems
  • Memory: durable episodes, proposals, reviews, skills, known fixes, procedures, and bundles

Anthropic decouples session, harness, and sandbox so failed harnesses or sandboxes can be replaced. PraxisBase applies the same philosophy to organizational learning: an agent can disappear after one repair run, but its useful experience can survive, be reviewed, be promoted, and become part of the next agent's context.

One important long-term capability is skill synthesis: repeated successful episodes should be summarized into reusable SKILL.md files, reviewed by AI, promoted into the shared skill registry, and loaded by later agents. The same loop should work for personal memories, project-local lessons, team knowledge, and organization-level policies.

What It Does

Codex / Claude Code / OpenCode / Hermes / OpenHuman / OpenClaw / K8s / Feishu
          |
          v
  temporary and persistent agent peers
          |
          v
    PraxisBase file protocol + CLI
          |
          v
  Git-backed durable knowledge layer
          |
          v
 static repair bundles + HTML inspection
          |
          v
       next agent starts smarter

Current Status

PraxisBase is currently organized around milestone gates rather than a single long-lived daemon:

Milestone Status Gate
M27 Personal GA Complete praxisbase personal release-audit --json
M28 Team OpenClaw repair self-evolution Complete praxisbase team release-audit --json
M29 Container/K8s incident experience Implemented and fixture-validated praxisbase team release-audit --json with optional K8s gates
M30 Feishu source integration Designed, not started Do not implement until M29 is explicitly closed

K8s is an optional team domain. In a workspace that has not been initialized with K8s seed knowledge, the three K8s audit gates report not_run and do not fail team_ga. Once K8s is enabled, those gates must pass with real bundle, incident intake, and boundary evidence.

OpenClaw Repair MVP

The first production path targets OpenClaw sandbox auto-repair:

  • praxisbase init creates the agent knowledge substrate skeleton
  • praxisbase repair-context openclaw --logs ... returns a compact repair bundle
  • agents submit repair episode records after each run
  • agents submit proposal records when they discover reusable knowledge
  • skill improvements can enter the same proposal/review/promotion lane
  • AI reviewer agents classify risk and approve routine changes
  • praxisbase promote --auto promotes approved proposals into stable knowledge
  • praxisbase build generates repair bundles, indexes, llms.txt, and HTML inspection output
  • GitLab Scheduled Pipelines run review, promotion, and build jobs

PraxisBase intentionally does not implement a central master agent, external vector DB, blockchain, live Kubernetes writes, or sre-autopilot internals. K8s support is a read-only incident knowledge domain: PraxisBase builds recommendation bundles and accepts incident episodes/proposals from a peer system, but it does not operate a cluster.

Knowledge Model

PraxisBase stores different knowledge lifecycles in different places:

Layer Carrier Examples
Protocol state .praxisbase/ inbox episodes, proposals, reviews, policies, schedules
Stable knowledge kb/ known fixes, procedures, decisions, notes, reviewed memory
Agent skills skills/ OpenClaw repair skills, K8s triage skills
Distribution dist/ repair bundles, indexes, HTML, llms.txt
Raw evidence external systems full logs, tickets, Feishu exports, object storage

Large raw logs stay outside Git. Git stores references, summaries, hashes, and redacted evidence.

Knowledge objects are classified across four dimensions:

Dimension Values
Scope personal, project, team, org
Layer preference, convention, technical, domain, project
Type model, decision, guideline, pitfall, process, known_fix, procedure, skill, policy, note
Maturity draft, verified, proven, stale, archived

Adapters should stay thin: hooks capture evidence, watchers support agents without hooks, and scheduled distill jobs turn captures into episodes, proposals, reports, and exceptions.

Native Memory Bridge

PraxisBase should reuse agent-native memory instead of replacing it. Existing Codex sessions, Hermes skill summaries, OpenHuman persona/preferences, OpenClaw repair records, and generic agent notes can enter as source refs with hashes and redacted summaries.

memory import backfills native memory into capture/proposal candidates. memory refresh sends reviewed PraxisBase knowledge back as runtime context, install snippets, or patch proposals. It is not silent bidirectional sync: native memory is a source and cache, while reviewed PraxisBase objects remain the shared authority.

Multi-Agent CLI Flow

The first multi-agent experience layer is CLI-first and proposal-based:

praxisbase install codex --dry-run --json
praxisbase context get --agent codex --stage diagnosis --query "openclaw auth expired" --json
praxisbase capture finish --agent codex --result success --source-ref raw-vault://codex/session-1 --source-hash sha256:session1 --summary "Fixed a project issue and tests passed." --json
praxisbase capture submit capture.json --json
praxisbase memory import --agent hermes --source hermes-memory.json --json
praxisbase memory refresh --agent hermes --target instruction-snippet --source-refs kb/known-fixes/openclaw-auth-expired.md --json
praxisbase distill run --json
praxisbase watch --agent claude-code --workspace . --once --json

These commands write only protocol state under .praxisbase/ and proposal candidates under .praxisbase/inbox/proposals/. Stable kb/ and skills/ changes still go through review and promotion.

Example: Hermes Skill Evolution

Hermes already has agent-managed skills, persistent memory, and curator-style skill maintenance. PraxisBase can reuse those outputs as proposal sources and send reviewed shared skills back as context or patch proposals.

Hermes is an accelerator, not a dependency: Codex, Claude Code, OpenCode, OpenHuman, OpenClaw, and generic agents must still work through the same CLI/file protocol.

Daily Experience Loop

PraxisBase supports an AI-first daily experience loop that collects agent experience from configured sources, chunks it, runs deterministic privacy gates, asks an AI model to distill reusable experience, and merges only redacted summaries into the wiki flow. The deterministic path remains available as explicit degraded mode for bootstrap and offline smoke, but it is not production-ready.

AI-First Quickstart

praxisbase bootstrap personal --agent codex --install-skill --json
praxisbase ai init --provider openai-compatible --model <model> --json
export PRAXISBASE_LLM_API_KEY=...
export PRAXISBASE_LLM_BASE_URL=https://api.openai.com/v1   # optional for OpenAI-compatible providers
praxisbase ai doctor --json
praxisbase daily run --mode personal --build-site --json
open dist/index.html

bootstrap personal discovers only specific safe personal paths such as ~/.codex/sessions, ~/.codex/archived_sessions, ~/.codex-cli-cliproxyapi/sessions, ~/.openclaw/memory/main.sqlite, and ~/.openclaw/reports. It does not scan the whole home directory.

Release Audits

Use release audits to verify what is actually usable in a workspace:

praxisbase personal release-audit --json
praxisbase team release-audit --json
praxisbase kb audit --json

To enable the optional K8s incident domain in a workspace:

praxisbase init --profile k8s
praxisbase build
praxisbase bundle fetch k8s-incident --signature k8s:pod-oomkilled --json
praxisbase team release-audit --json

Runtime protocol state under .praxisbase/ and generated site/bundle output under dist/ are local artifacts. Stable knowledge belongs in kb/ and skills/; raw logs, full sessions, and private memory stay outside Git as source references plus hashes.

Personal Daily Flow

praxisbase source add local-codex --agent codex --type local --path ~/.codex/archived_sessions --scope personal
praxisbase source add local-openclaw --agent openclaw --type local --path ~/.openclaw/exports/latest.json --scope project
praxisbase daily run --mode personal --build-site --json

For offline bootstrap smoke only:

praxisbase daily run --mode personal --degraded --build-site --json

Degraded mode is visibly marked as production_ready: false in the daily report.

Team GitLab Daily Flow

praxisbase source add openclaw-bot --agent openclaw --channel feishu --type openclaw-api --remote bot-prod --scope team
praxisbase source add claude-repair-log --agent claude-code --type http --url "$LOG_API" --scope team
praxisbase daily run --mode team-git --branch harvest/daily --commit --push --build-site --json

Team mode enforces privacy before AI distill: personal scope, private chat content, and raw credentials are rejected before model calls or proposal generation. Uncertain cases route to .praxisbase/exceptions/human-required. Teams should run this in GitLab with protected branches and scheduled pipelines so reviewed knowledge, reports, and HTML are auditable.

Why This Exists

Teams that operate many agent sandboxes have a different problem from ordinary documentation:

  • a repair agent may live for minutes
  • a sandbox may be deleted after use
  • a persistent bot may be upgraded or replaced
  • model and harness assumptions will change
  • the useful repair experience must survive all of that

PraxisBase makes the durable part explicit. It is the shared memory, skill registry, review lane, skill synthesis lane, and repair bundle generator for disposable agents.

Current Documents

Roadmap

  • M27: Personal knowledge base GA, AI distill, personal wiki/skill output, GBrain sidecar export, and clean provenance gates.
  • M28: Team OpenClaw repair self-evolution through repair context, episode/proposal intake, review/promote, governance, and team release audit.
  • M29: Optional K8s incident experience domain with read-only bundles, sre-autopilot episode intake, and K8s boundary gates.
  • M30: Feishu source integration is designed but not started; it should only begin after M29 is explicitly closed.
  • Later: Multi-repo federation, stronger provenance, external retrieval integrations, and cross-team synchronization.

Name

PraxisBase is the English project name. 知行基座 is the Chinese name.

PraxisBase means the durable base where agents turn knowledge into action and action back into reusable knowledge. The English name keeps the infrastructure feel of a shared substrate; the Chinese name preserves "知行", which fits the loop this project cares about most: learn, repair, verify, promote, and reuse.

References

License

MIT

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages