your company knows things. who owns the billing service. why you moved off DynamoDB in March. what broke last quarter and how it got fixed. which channel the payments team actually watches. that knowledge is real — but it isn't anywhere an AI agent can reach it. it's in Slack threads, a few Google Docs, email, source control, and four people's heads.

so every time you want an agent to do something genuinely useful — triage an incident, draft a quarterly review, answer a new hire's question — it starts from zero. it has the reasoning. it doesn't have the context. and the context is the slow part.

so I built mindframe: it builds a knowledge base of how your organization actually works, and runs agents that act on it.

not a framework. a bundle.

mindframe isn't a thing you build on. it's a thing you install. /softwaresoftware:install mindframe pulls down seven components and wires them together, and /mindframe:setup onboards them against your real systems — it probes what you've got (Slack, GitHub, Gmail, your infrastructure), walks you through credentials, and bootstraps the knowledge base from your actual data.

the knowledge base is just markdown

the knowledge base is a per-customer vault: one Markdown note per service, project, decision, person, incident. structured frontmatter, grep-friendly, no embeddings, owned by you as a git repo. a librarian agent keeps it current. the agent reads it the way a senior employee would — "this is payments-api, backend-payments owns it, here's the runbook, here's what happened in March."

no RAG, no vector DB. cosine similarity matches words; the agent understands intent. and because the vault is a git repo, every fact has a history.

the agents do the work

on top of the knowledge base sits a library of deliverable skills. each one takes a request, grounds it in the vault plus live connectors, and produces something a human can use.

the first skill is incident triage. a pod starts crash-looping; an agent reads the cluster, greps the vault for the matching runbook and who owns the service, cross-references recent commits to name a prime suspect, and posts a recommendation with a one-click rollback. fifteen seconds, and the on-call human arrives at a decision instead of an investigation.

but incident triage is the first skill, not the point. the point is the pattern: a request comes in, the agent grounds it in what your org knows, an artifact comes out. "show me a QBR for Q1." "who owns the checkout flow now." "what changed about our deploy process this quarter." same shape, different deliverable. the library grows.

two paths

mindframe acts on two paths, kept strictly separate. the push path reacts to events — a webhook fires, an ephemeral agent spawns, runs a skill, exits. the pull path watches continuously — a dashboard probes services, daemons, and agents and renders current status. the dispatcher is the ears; the dashboard is the eyes.

capabilities, not products

every dependency in the bundle is an abstract capability, not a named product. a skill says "send this to the right channel" — it never says "use Slack." a resolver binds the capability to whatever fits your environment. notifications go to Slack on one install and email on the next, and the bundle doesn't change.

and there's no API key. the agents run as claude processes authenticated through the Claude Code subscription — nothing to provision, rotate, or leak. mindframe runs locally, against your real systems. nothing about your organization is uploaded to run it.

install it

claude plugin marketplace add softwaresoftware-dev/softwaresoftware-plugins
claude plugin install softwaresoftware@softwaresoftware-plugins
/softwaresoftware:install mindframe
/mindframe:setup

the first three lines install the bundle. /mindframe:setup does the onboarding — probes your machine, walks you through credentials, bootstraps the knowledge base from your real systems, and runs a smoke test end to end.

then ask it for something.