agentirc-cli 7.3.0__tar.gz → 8.0.0__tar.gz

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/CHANGELOG.md

@@ -4,6 +4,25 @@ All notable changes to this project will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [8.0.0] - 2026-04-22
+
+### Added
+
+- `culture afi`, `culture identity`, and `culture secret` surfaced as (coming soon) namespaces in `culture explain` output. `culture identity` will wrap a future standalone `zehut-cli`; `culture secret` will wrap `shushu-cli`; `culture afi` shares its name with the standalone `afi-cli`.
+
+### Changed
+
+- BREAKING: Renamed `culture agex` to `culture devex` (developer experience) — more familiar terminology and visually distinct from `culture agent`. The upstream `agex-cli` / `agent_experience` library is unchanged; only culture's public command name differs.
+- Positioning docs, README, and site chrome refreshed to reflect the new identity: culture is the framework of agreements that makes agent behavior portable, inspectable, and effective, surfacing explain/overview/learn at every CLI level.
+
+## [7.4.0] - 2026-04-22
+
+### Added
+
+- culture agex passthrough to the standalone agex CLI (new subcommand embedding agex via typer)
+- Universal verbs culture explain, culture overview, culture learn at the CLI root, with a per-topic handler registry (culture/cli/introspect.py)
+- agex-cli>=0.13,<1.0 as a library dependency
+
 ## [7.3.0] - 2026-04-21
 
 ### Added

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentirc-cli
-Version: 7.3.0
+Version: 8.0.0
 Summary: Legacy alias for culture — install culture instead
 Project-URL: Homepage, https://github.com/OriNachum/culture
 Author: Ori Nachum
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
 Requires-Python: >=3.12
+Requires-Dist: agex-cli<1.0,>=0.13
 Requires-Dist: aiohttp>=3.9
 Requires-Dist: anthropic>=0.40
 Requires-Dist: claude-agent-sdk>=0.1
@@ -24,18 +25,23 @@ Description-Content-Type: text/markdown
 
 # Culture
 
-The complete human-agent collaboration system built around AgentIRC.
+The framework of agreements that makes agent behavior portable, inspectable, and effective.
 
 **AgentIRC** is the IRC-native runtime for persistent AI agents and humans in shared live rooms.
-**Culture** is the full solution — CLI, harnesses, console, workflows, and multi-machine mesh.
+**Culture** is the full solution — CLI with universal introspection verbs (`explain` / `overview` / `learn` at every level), harnesses, console, workflows, and multi-machine mesh. It ships `culture devex` today (powered by the standalone `agex-cli`) and will add `culture afi`, `culture identity`, and `culture secret` next.
 
 ## Start here
 
 - [Quickstart](https://culture.dev/quickstart/) — install and start in 5 minutes
 - [Choose a Harness](https://culture.dev/choose-a-harness/) — Claude Code, Codex, Copilot, ACP
+- [`culture devex` and universal verbs](https://culture.dev/reference/cli/devex/) — the inspectable CLI
 - [AgentIRC Architecture](https://culture.dev/agentirc/architecture-overview/) — the runtime layer
 - [Vision & Patterns](https://culture.dev/vision/) — the broader model
 
+## What's next
+
+`culture afi` (Agent First Interface), `culture identity` (mesh identity / key management, wrapping the standalone `zehut-cli`), and `culture secret` (credential management, wrapping `shushu-cli`) are on the way. Run `culture explain` for the always-current registry of what's ready vs. coming soon.
+
 ## Install
 
 ```bash

agentirc_cli-8.0.0/README.md

@@ -0,0 +1,34 @@
+# Culture
+
+The framework of agreements that makes agent behavior portable, inspectable, and effective.
+
+**AgentIRC** is the IRC-native runtime for persistent AI agents and humans in shared live rooms.
+**Culture** is the full solution — CLI with universal introspection verbs (`explain` / `overview` / `learn` at every level), harnesses, console, workflows, and multi-machine mesh. It ships `culture devex` today (powered by the standalone `agex-cli`) and will add `culture afi`, `culture identity`, and `culture secret` next.
+
+## Start here
+
+- [Quickstart](https://culture.dev/quickstart/) — install and start in 5 minutes
+- [Choose a Harness](https://culture.dev/choose-a-harness/) — Claude Code, Codex, Copilot, ACP
+- [`culture devex` and universal verbs](https://culture.dev/reference/cli/devex/) — the inspectable CLI
+- [AgentIRC Architecture](https://culture.dev/agentirc/architecture-overview/) — the runtime layer
+- [Vision & Patterns](https://culture.dev/vision/) — the broader model
+
+## What's next
+
+`culture afi` (Agent First Interface), `culture identity` (mesh identity / key management, wrapping the standalone `zehut-cli`), and `culture secret` (credential management, wrapping `shushu-cli`) are on the way. Run `culture explain` for the always-current registry of what's ready vs. coming soon.
+
+## Install
+
+```bash
+uv tool install culture
+culture server start
+```
+
+## Documentation
+
+- **[culture.dev](https://culture.dev)** — the full solution: quickstart, harnesses, guides, vision
+- **[culture.dev/agentirc](https://culture.dev/agentirc/)** — the runtime layer: architecture, protocol, federation
+
+## License
+
+[MIT](LICENSE)

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/_config.culture.yml

@@ -1,6 +1,6 @@
 title: Culture
 description: >-
-  The professional workspace for agents.
+  The framework of agreements that makes agent behavior portable, inspectable, and effective — a professional workspace for agents with a CLI that explains itself.
 url: "https://culture.dev"
 baseurl: ""
 build_site: culture
@@ -12,7 +12,7 @@ twitter:
 social:
   name: Culture
   links:
-    - https://github.com/OriNachum/culture
+    - https://github.com/agentculture/culture
 
 author:
   name: Ori Nachum
@@ -36,13 +36,18 @@ aux_links:
     - "/agentirc/"
   "Agent Experience":
     - "https://culture.dev/agex/"
+  "Citation CLI":
+    - "/citation-cli/"
   "GitHub":
-    - "https://github.com/OriNachum/culture"
+    - "https://github.com/agentculture/culture"
 
 aux_links_new_tab: false
 
 footer_content: >-
   Culture — human-agent collaboration built around
   <a href="/agentirc/">AgentIRC</a>.
+  Inspectable CLI via <a href="/reference/cli/devex/">culture devex</a>
+  (explain / overview / learn at every level).
   Agent Experience via <a href="https://culture.dev/agex/">agex-cli</a>.
-  Source on <a href="https://github.com/OriNachum/culture">GitHub</a>.
+  Code distribution via <a href="/citation-cli/">Citation CLI</a>.
+  Source on <a href="https://github.com/agentculture/culture">GitHub</a>.

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/_data/sites.yml

@@ -1,3 +1,4 @@
 agentirc: https://culture.dev/agentirc/
 agex: https://culture.dev/agex/
+citation_cli: https://culture.dev/citation-cli/
 culture: https://culture.dev

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/_includes/head_custom.html

@@ -4,3 +4,4 @@
 <link rel="icon" type="image/png" sizes="16x16" href="{{ '/assets/images/favicon-16x16.png' | relative_url }}">
 <link rel="apple-touch-icon" sizes="180x180" href="{{ '/assets/images/apple-touch-icon.png' | relative_url }}">
 <link rel="related" href="{{ site.data.sites.agex }}" title="Agent Experience">
+<link rel="related" href="{{ site.data.sites.citation_cli }}" title="Citation CLI">

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/culture/cli/__init__.py

@@ -7,6 +7,12 @@ Commands are organized into noun-based groups:
     culture channel  {list,read,message,who}
     culture bot      {create,start,stop,list,inspect,archive,unarchive}
     culture skills   {install}
+    culture devex    {...developer-experience passthrough (powered by agex-cli)...}
+
+Universal verbs (available at the root):
+    culture explain [topic]    full description of topic (default: culture)
+    culture overview [topic]   shallow summary
+    culture learn [topic]      agent-facing onboarding prompt
 """
 
 from __future__ import annotations
@@ -16,9 +22,16 @@ import logging
 import sys
 
 from culture import __version__
-from culture.cli import agent, bot, channel, mesh, server, skills
+from culture.cli import agent, bot, channel, devex, introspect, mesh, server, skills
+
+GROUPS = [agent, server, mesh, channel, bot, skills, devex, introspect]
+
 
-GROUPS = [agent, server, mesh, channel, bot, skills]
+def _names_of(group) -> set[str]:
+    names = getattr(group, "NAMES", None)
+    if names is not None:
+        return set(names)
+    return {group.NAME}
 
 
 def _build_parser() -> argparse.ArgumentParser:
@@ -48,7 +61,7 @@ def main() -> None:
 
     try:
         for group in GROUPS:
-            if args.command == group.NAME:
+            if args.command in _names_of(group):
                 group.dispatch(args)
                 return
         parser.print_help()

agentirc_cli-8.0.0/culture/cli/devex.py

@@ -0,0 +1,111 @@
+"""`culture devex` — passthrough to the standalone agex CLI.
+
+Also registers universal-verb handlers for the ``devex`` topic so
+``culture explain devex`` / ``culture overview devex`` /
+``culture learn devex`` route through culture's universal-verb path.
+
+Under the hood, ``devex`` is powered by the standalone ``agex-cli``
+(``agent_experience`` package). The command name differs for
+familiarity with the developer-experience vocabulary; the underlying
+tool is the same.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import io
+import sys
+
+from culture.cli import introspect
+
+NAME = "devex"
+
+
+def _run_devex(argv: list[str]) -> None:
+    """Invoke the underlying agex typer app in-process.
+
+    Uses standalone_mode=True (the typer default) so typer's own --help,
+    --version, and Exit handling work unchanged. Typer calls ``sys.exit``
+    when done, raising ``SystemExit``; this function lets that propagate
+    so the caller (the ``culture devex`` passthrough) exits with the code
+    the user expects. Callers that need to capture output and translate
+    the exit into a return value should use :func:`_capture_devex` instead.
+    """
+    try:
+        from agent_experience.cli import app
+    except ImportError as exc:  # pragma: no cover — declared dep
+        print(f"agex-cli is not installed: {exc}", file=sys.stderr)
+        sys.exit(2)
+    app(args=argv)
+
+
+def _capture_devex(argv: list[str]) -> tuple[str, int]:
+    """Run devex with stdout + stderr captured, translating SystemExit.
+
+    The universal-verb handlers need ``(output, exit_code)`` rather than a
+    process-level exit, so we deliberately catch ``SystemExit`` here and
+    translate it into a return value. The :func:`_run_devex` variant is for
+    the passthrough path where the exit must propagate.
+    """
+    buf = io.StringIO()
+    try:
+        with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+            _run_devex(argv)
+    except SystemExit as exc:  # NOSONAR S5754 — see docstring
+        # typer calls sys.exit() on completion even for success, so this
+        # is the normal exit path; the trailing `return ... 0` only runs
+        # if _run_devex somehow returns without raising (defensive).
+        code = exc.code
+        if code is None:
+            return buf.getvalue(), 0
+        if isinstance(code, int):
+            return buf.getvalue(), code
+        return buf.getvalue() + str(code), 1
+    return buf.getvalue(), 0
+
+
+# --- universal-verb topic handlers for ``devex`` ---------------------------
+
+
+def _devex_explain(_topic: str | None) -> tuple[str, int]:
+    # The underlying agex library refers to itself as "agex"; that's what
+    # we pass to its own explain verb. The culture-facing name is devex.
+    return _capture_devex(["explain", "agex"])
+
+
+def _devex_overview(_topic: str | None) -> tuple[str, int]:
+    return _capture_devex(["overview", "--agent", "claude-code"])
+
+
+def _devex_learn(_topic: str | None) -> tuple[str, int]:
+    return _capture_devex(["learn", "--agent", "claude-code"])
+
+
+introspect.register_topic(
+    "devex",
+    explain=_devex_explain,
+    overview=_devex_overview,
+    learn=_devex_learn,
+)
+
+
+# --- CLI group protocol ---------------------------------------------------
+
+
+def register(subparsers: "argparse._SubParsersAction") -> None:
+    # prefix_chars=chr(0) means the devex subparser has no recognized flag
+    # prefix character, so every token (including --help, --version) is
+    # treated as positional and captured in devex_args for typer to handle.
+    p = subparsers.add_parser(
+        NAME,
+        help="Run the agex developer-experience CLI via passthrough",
+        add_help=False,
+        prefix_chars=chr(0),
+    )
+    p.add_argument("devex_args", nargs=argparse.REMAINDER, help="Arguments passed to agex")
+
+
+def dispatch(args: argparse.Namespace) -> None:
+    rest = list(getattr(args, "devex_args", []) or [])
+    _run_devex(rest)

agentirc_cli-8.0.0/culture/cli/introspect.py

@@ -0,0 +1,189 @@
+"""Universal introspection verb dispatcher.
+
+Registers three top-level verbs (``explain``, ``overview``, ``learn``)
+on the culture CLI and dispatches each to a per-topic handler.
+
+The module conforms to the extended culture CLI group protocol:
+exports ``NAMES`` (frozenset) instead of the singular ``NAME``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from typing import Callable
+
+_log = logging.getLogger(__name__)
+
+Handler = Callable[[str | None], tuple[str, int]]
+
+NAMES = frozenset({"explain", "overview", "learn"})
+
+_explain: dict[str, Handler] = {}
+_overview: dict[str, Handler] = {}
+_learn: dict[str, Handler] = {}
+
+_REGISTRIES: dict[str, dict[str, Handler]] = {
+    "explain": _explain,
+    "overview": _overview,
+    "learn": _learn,
+}
+
+
+def register_topic(
+    topic: str,
+    *,
+    explain: Handler | None = None,
+    overview: Handler | None = None,
+    learn: Handler | None = None,
+) -> None:
+    """Register handlers for a topic. Any verb may be omitted.
+
+    Re-registration is last-write-wins; a warning is logged when an existing
+    handler is overwritten so accidental double-registration is visible at
+    culture's default INFO log level.
+    """
+    for verb, handler, registry in (
+        ("explain", explain, _explain),
+        ("overview", overview, _overview),
+        ("learn", learn, _learn),
+    ):
+        if handler is None:
+            continue
+        if topic in registry:
+            _log.warning("overriding %s handler for topic %r", verb, topic)
+        registry[topic] = handler
+
+
+def _clear_registry() -> None:
+    """Test-only: wipe all registries, then re-register the root handlers."""
+    _explain.clear()
+    _overview.clear()
+    _learn.clear()
+    _register_root()
+
+
+def _resolve(verb: str, topic: str | None) -> tuple[str, int]:
+    registry = _REGISTRIES[verb]
+    effective = topic if topic is not None else "culture"
+    handler = registry.get(effective)
+    if handler is None:
+        # Known-but-unregistered namespaces are advertised via _NAMESPACES
+        # in `culture explain` output with "(coming soon)". Surface that
+        # same framing on a direct `culture <verb> <ns>` call instead of
+        # failing as if the topic were unknown. Exit 0 because this is a
+        # known future state, not a user error.
+        if effective in _NAMESPACES:
+            return (
+                f"`culture {effective}` — coming soon. "
+                f"Not yet implemented. Run `culture explain` to see the "
+                f"current registry of namespaces.\n",
+                0,
+            )
+        available = sorted(registry.keys())
+        msg = (
+            f"unknown topic '{effective}' for {verb};"
+            f" available: {', '.join(available) or '(none)'}"
+        )
+        return msg, 1
+    return handler(topic)
+
+
+def explain(topic: str | None) -> tuple[str, int]:
+    return _resolve("explain", topic)
+
+
+def overview(topic: str | None) -> tuple[str, int]:
+    return _resolve("overview", topic)
+
+
+def learn(topic: str | None) -> tuple[str, int]:
+    return _resolve("learn", topic)
+
+
+_NAMESPACES = (
+    "agent",
+    "server",
+    "mesh",
+    "channel",
+    "bot",
+    "skills",
+    "devex",
+    "afi",
+    "identity",
+    "secret",
+)
+
+
+def _culture_explain(_topic: str | None) -> tuple[str, int]:
+    lines = [
+        "# Culture",
+        "",
+        "Culture is the framework of agreements that makes agent behavior",
+        "portable, inspectable, and effective. It hosts a mesh of IRC servers",
+        "where AI agents collaborate, share knowledge, and coordinate work.",
+        "",
+        "## Namespaces",
+        "",
+    ]
+    for ns in _NAMESPACES:
+        registered = any(ns in registry for registry in _REGISTRIES.values())
+        marker = "" if registered else "  (coming soon)"
+        lines.append(f"- `culture {ns}`{marker}")
+    lines.append("")
+    lines.append("## Universal verbs")
+    lines.append("")
+    lines.append("- `culture explain [topic]` — deep description")
+    lines.append("- `culture overview [topic]` — shallow map")
+    lines.append("- `culture learn [topic]` — agent onboarding prompt")
+    return "\n".join(lines) + "\n", 0
+
+
+def _culture_overview(_topic: str | None) -> tuple[str, int]:
+    return (
+        "Culture: agent IRC mesh. Namespaces: "
+        + ", ".join(_NAMESPACES)
+        + ". Universal verbs: explain, overview, learn.\n",
+        0,
+    )
+
+
+def _culture_learn(_topic: str | None) -> tuple[str, int]:
+    from culture.learn_prompt import generate_learn_prompt
+
+    return generate_learn_prompt(), 0
+
+
+def _register_root() -> None:
+    register_topic(
+        "culture",
+        explain=_culture_explain,
+        overview=_culture_overview,
+        learn=_culture_learn,
+    )
+
+
+_register_root()
+
+
+# --- CLI group protocol ---------------------------------------------------
+
+
+def register(subparsers: "argparse._SubParsersAction") -> None:
+    for verb in ("explain", "overview", "learn"):
+        p = subparsers.add_parser(verb, help=f"{verb.capitalize()} a topic (culture by default)")
+        p.add_argument("topic", nargs="?", default=None, help="Topic to inspect")
+
+
+def dispatch(args: argparse.Namespace) -> None:
+    import sys
+
+    verb = args.command
+    topic = getattr(args, "topic", None)
+    stdout, code = _resolve(verb, topic)
+    if stdout:
+        stream = sys.stdout if code == 0 else sys.stderr
+        end = "" if stdout.endswith("\n") else "\n"
+        print(stdout, end=end, file=stream)
+    if code != 0:
+        sys.exit(code)

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/docs/culture/features.md

@@ -70,6 +70,21 @@ description: Everything in the workspace — grouped by who it's for.
   <a class="feature-group-deep" href="{{ '/agentirc/architecture-overview/' | relative_url }}">Under the hood → AgentIRC</a>
 </div>
 
+<div class="feature-group">
+  <div class="feature-group-head">
+    <span class="feature-group-kicker">05</span>
+    <span class="feature-group-title">Introspection &amp; experience</span>
+  </div>
+  <p class="feature-group-desc">The CLI explains itself. Each namespace owns its own docs.</p>
+  <div class="feature-group-items">
+    <div>culture explain / overview / learn</div>
+    <div>culture devex (powered by agex-cli)</div>
+    <div>culture afi (coming soon)</div>
+    <div>culture identity / secret (coming soon)</div>
+  </div>
+  <a class="feature-group-deep" href="{{ '/reference/cli/devex/' | relative_url }}">Read the contract →</a>
+</div>
+
 <div class="callout-relationship">
   <p><strong>Want the runtime internals?</strong> AgentIRC is the IRC-native server at the core. <a href="{{ '/agentirc/' | relative_url }}">Explore AgentIRC →</a></p>
 </div>

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/docs/culture/index.md

@@ -9,7 +9,7 @@ description: The professional workspace for agents.
 <div class="hero">
   <p class="hero-label">The professional workspace for agents</p>
   <h1 class="hero-headline">Where your agents actually&nbsp;work.</h1>
-  <p class="hero-sub">Persistent rooms. Real colleagues. One CLI. Multi-machine mesh.</p>
+  <p class="hero-sub">Persistent rooms. Real colleagues. A CLI that explains itself. Multi-machine mesh.</p>
   <div>
     <a href="{{ '/quickstart/' | relative_url }}" class="btn-cta btn-cta--primary">Quickstart</a>
     <a href="{{ '/features/' | relative_url }}" class="btn-cta btn-cta--secondary">See the workspace</a>
@@ -28,7 +28,7 @@ description: The professional workspace for agents.
   <div class="stack-row">
     <span class="stack-row-label">You</span>
     <div class="stack-row-content">
-      <strong>Culture CLI</strong> <span class="text-muted">uv tool install culture</span>
+      <strong>Culture CLI</strong> <span class="text-muted">uv tool install culture · explain · overview · learn at every level</span>
     </div>
   </div>
   <div class="stack-row">
@@ -76,6 +76,10 @@ description: The professional workspace for agents.
     <p class="docs-card-title">Join as a Human</p>
     <p class="docs-card-desc">Console or any IRC client</p>
   </a>
+  <a href="{{ '/reference/cli/devex/' | relative_url }}" class="docs-card">
+    <p class="docs-card-title">Inspectable CLI</p>
+    <p class="docs-card-desc">culture explain · overview · learn · devex</p>
+  </a>
 </div>
 
 <div class="callout-relationship">

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/docs/culture/mental-model.md

@@ -49,6 +49,21 @@ This is the Reflective Development paradigm: the system is self-improving becaus
 the participants — both human and AI — have access to the same context and the
 same tools.
 
+Reflection is also built into the CLI itself through three **universal verbs**
+available at every level of the command tree:
+
+- `explain X` — deep description of X and everything under X.
+- `overview X` — shallow map of X.
+- `learn X` — agent-facing onboarding prompt for operating X, so an agent
+  doesn't have to re-explore X every time it connects.
+
+Each namespace owns its own handlers — `culture` is pure plumbing. An agent
+can run `culture explain`, `culture explain devex`, `culture overview mesh`,
+or `culture learn agent` and get progressively-scoped self-description
+without leaving the shell. See the
+[`culture devex` reference]({{ '/reference/cli/devex/' | relative_url }})
+for the contract and the current registry of topics.
+
 ## Organization
 
 Multiple Culture instances link together through federation. Each instance is

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/docs/culture/vision.md

@@ -60,3 +60,26 @@ read and write plain text, which is what language models are built to do.
 The protocol handles presence, channels, messaging, and federation.
 Culture extends it with attention routing, skills, and agent lifecycle
 management — but the foundation is standard IRC.
+
+## Upcoming
+
+Culture is the framework of agreements that makes agent behavior portable,
+inspectable, and effective. Beyond the workspace runtime and the
+[`culture devex`]({{ '/reference/cli/devex/' | relative_url }}) namespace
+(powered by the standalone `agex-cli`) that already ship, three more
+first-class namespaces are next:
+
+- **`culture afi`** — Agent First Interface. Standards and scaffolding
+  for tools whose primary consumer is an AI agent (CLI / MCP / HTTP).
+  Wraps the standalone `afi-cli`.
+- **`culture identity`** — Identity management across the mesh. Wraps a
+  standalone `zehut-cli` (Hebrew: "identity"). The command you'll reach
+  for to name agents, issue keys, and federate trust between servers.
+- **`culture secret`** — Secret management. Wraps a standalone
+  `shushu-cli`. Handles credentials and sensitive config for agents and
+  harnesses.
+
+Culture uses English for its first-class nouns; the standalone CLIs keep
+their brand names. You don't have to remember which is which —
+`culture explain` is the always-current source of truth and lists each
+namespace's current state (registered vs. coming soon) at runtime.

{agentirc_cli-7.3.0 → agentirc_cli-8.0.0}/docs/culture/what-is-culture.md

@@ -3,7 +3,7 @@ title: "What is Culture?"
 parent: "Vision & Patterns"
 nav_order: 1
 sites: [culture]
-description: Culture is a professional workspace for specialized agents. Here's what that means.
+description: Culture is the framework that makes agent behavior portable, inspectable, and effective — a professional workspace for specialized agents.
 permalink: /what-is-culture/
 redirect_from:
   - /why-culture/
@@ -11,12 +11,14 @@ redirect_from:
 
 # What is Culture?
 
-Culture is a professional workspace for specialized agents. Through AgentIRC,
-it provides the shared environment — rooms, presence, roles, coordination,
-and history that persists across sessions — where agents and humans work
-together. Harnesses are optional connectors: they let an agent stay present
-in the culture without being pushed to read every message, so participating
-in the workspace doesn't mean drowning in it.
+Culture is the framework of agreements that makes agent behavior portable,
+inspectable, and effective. Concretely, it provides two things: a shared
+professional workspace for specialized agents (rooms, presence, roles,
+coordination, and history via AgentIRC), and a CLI whose every level
+explains itself so agents can operate the system without re-discovering it
+each session. Harnesses are optional connectors: they let an agent stay
+present in the culture without being pushed to read every message, so
+participating in the workspace doesn't mean drowning in it.
 
 ## A professional workspace for specialized agents
 
@@ -47,6 +49,24 @@ Teachability is real and important — but it is not what sets Culture apart.
 What sets Culture apart is the shared professional workspace of specialized
 agents.
 
+## Inspectable from any level
+
+Culture ships three **universal verbs** — `explain`, `overview`, and
+`learn` — available at every level of the CLI command tree, each scoped
+to that node and its descendants:
+
+- `culture explain [topic]` — full description (deep).
+- `culture overview [topic]` — shallow map.
+- `culture learn [topic]` — agent-facing onboarding prompt so an agent
+  can operate the topic without re-exploring it each session.
+
+Each namespace owns its own handlers — culture is pure plumbing. Today
+the [`culture devex`]({{ '/reference/cli/devex/' | relative_url }})
+namespace (powered by the standalone `agex-cli`) is registered;
+`culture afi`, `culture identity`, and `culture secret` are surfaced as
+`(coming soon)` and will be added in future releases following the same
+pattern.
+
 ## Reference points
 
 Systems like OpenClaw are useful reference points because they focus on the
@@ -69,3 +89,4 @@ not a replacement for what they already carry.
 - For the broader model and where this is going → [Vision]({{ '/vision/' | relative_url }}).
 - For the conceptual model (spaces, membership, reflection) → [Mental model]({{ '/mental-model/' | relative_url }}).
 - For the capability list → [Features]({{ '/features/' | relative_url }}).
+- For the CLI's self-explaining surface → [`culture devex` and universal verbs]({{ '/reference/cli/devex/' | relative_url }}).