Console

ClawMem Console is the human UI for the same GitHub-compatible memory backend your agents use.

Open it at https://console.clawmem.ai.

Use Console when you want to see what your agents know, inspect where memory came from, bind managed agents, browse wiki knowledge, or manage the permissions and invitations around shared memory spaces.

What Console is for

Console makes the human ↔ agent ↔ memory relationship visible and manageable.

It lets a human:

• bind an agent account into a workspace
• grant that agent repo, org, or team access during binding
• switch into a bound agent account view
• inspect memories, source provenance, wiki pages, labels, and knowledge graph connections
• manage repo permissions, collaborators, team grants, organization membership, and pending invitations
• create or revoke invitations when people or agents need access to shared memory spaces
• verify that an agent sees only the memory spaces it should see

ClawMem agents can store and recall memory through runtime tools. Console gives humans the oversight layer: identity, access, invitations, permissions, inspection, correction, and navigation.

Console capabilities

Agent onboarding

Bind an agent account, queue repo or team access, complete the bind invite in the agent runtime, then verify the binding.

Account switching

Switch from a human account into a bound agent account to inspect Console from the agent’s perspective.

Knowledge graph

See memory nodes and cross-references as a graph so you can understand how agent knowledge connects.

Memories tab

Browse active and closed memory records, filter by labels, search by topic, and inspect source links.

Wiki browser

Browse repo-backed wiki pages in a tree for runbooks, team contracts, source registries, and project knowledge.

Permissions and invitations

Manage collaborators, team grants, organization members, repo invitations, and org invitations.

Agent onboarding and account switching

The newest Console onboarding flow is intentionally explicit. Installing ClawMem gives an agent its own identity and default repo. Binding connects that agent to a human-managed workspace and optional shared memory permissions.

1. Open Console as the human operator. Sign in with the account that should manage the agent.
2. Go to Agents. This is the binding hub for managed agents.
3. Choose the access to grant. Queue repo/project access, org/team access, and the permission level the agent should receive.
4. Create a bind invite. Console generates a bind invite for that agent.
5. Complete the invite in the agent runtime. The agent confirms the bind from its own runtime.
6. Verify the agent entry. Check granted repos, teams, token/reset controls, and display name.
7. Switch into the agent account view. Confirm the agent sees exactly the intended memory spaces.

Agents page: bind an agent, queue repository access, queue team access, and review which agents are already connected.

Tip

Onboarding is not just “install the plugin.” For managed agents, the important step is deciding which memory spaces the agent should see and then verifying that view after binding.

Knowledge graph

The Console Insights view renders a memory repo as an interactive knowledge graph. type:memory records become nodes, and cross-references between records become edges.

Use the graph when you want to:

• see the shape of what an agent or team knows
• find clusters of related decisions, conventions, lessons, or tasks
• follow links from one memory record to another
• investigate why a topic keeps surfacing in recall
• audit gaps, stale hubs, or disconnected knowledge

Knowledge graph: inspect connected memory nodes and relationships as an investigation view.

The graph is an investigation surface. The default work starts from agents, memory records, wiki pages, and access management; the graph helps explain relationships once the repo has enough connected knowledge.

Memories tab

The Memories tab is where humans inspect durable memories directly.

Use it to:

• browse open type:memory records that are active recall material
• inspect closed memories that are no longer active but remain auditable
• filter by kind:*, topic:*, and workflow labels
• search by title or body text
• open a memory and follow source links

Memories tab: inspect durable memory records, labels, active/stale state, and source links in one place.

Conversation records are not the main Console capability here. They are the source provenance behind a memory. When a memory links to its source, humans can follow that link to check what the user actually said, which assistant turn created or changed the memory, and whether the record should be updated or closed.

Wiki knowledge

Wiki pages are for curated, long-form knowledge inside a memory repo.

Use wiki pages for:

• team contracts
• workflow runbooks
• source registries
• architecture notes
• onboarding docs
• project indexes that link related memory issues and conversations

Console lets humans browse wiki pages by path, search content, and inspect labels or backlinks when they have access.

Wiki tab: browse repo-backed knowledge as a tree, open pages, and inspect labels attached to wiki knowledge.

Permissions, teams, and invitations

Console is also the human governance surface for shared memory.

Use it to manage:

• repo collaborators and permission levels
• pending repository invitations
• team grants on organization-owned repos
• organization members and pending org invitations
• team membership and repo access for each team
• access verification for bound agents

This matters because ClawMem memory is collaborative infrastructure. A human should be able to decide who, including which agent, can read, write, or administer each memory space.

Access settings: manage collaborators, pending invitations, team grants, and permission levels for a memory repo.

Console capabilities in practice

Agent binding verification

1. Open Agents.
2. Confirm the target agent appears in the bound-agent list.
3. Review the repo and team grants attached during binding.
4. Use the account switcher to enter that agent’s account view.
5. Open the expected repo or org surface.
6. Switch back to the human account.

Agent knowledge inspection

1. Open the relevant memory repo.
2. Go to Memories for active records.
3. Use Insights when you need a graph of related memories.
4. Open a memory and follow source provenance links.

Memory audit and repair

1. Go to Memories.
2. Filter by topic:* or kind:* labels.
3. Search by title or body text.
4. Open the memory, inspect source provenance, then ask an agent with write access to update or close stale records.

Wiki knowledge browsing

Use wiki pages for team contracts, runbooks, source registries, concepts, and project documentation.

A good wiki page acts as an index: it explains the current state and links to the memory issues or conversations that justify it.

Access and repo governance

When your account has permission, Console can help with:

• repository name, description, and visibility
• label creation and cleanup
• collaborator access
• team and organization access surfaces
• repository and organization invitations
• token/access verification for bound agents

Console and agents share one source of truth

Console reads the same repos, issues, comments, labels, wiki pages, and permissions that agents use.

• A memory you see in Console is the same type:memory issue an agent can recall.
• Source provenance links point back to the records created by the integration.
• A wiki page you open in Console is stored through the GitHub-compatible wiki backend.
• A label, collaborator, team, or access change can affect what agents can recall or update.

That is the point of ClawMem’s Console: humans can manage agents without treating agent memory as a black box.