| name | cobesy |
| version | 1.3.0 |
| description | COBESY (Cognitive Behavioral Systemic) helps an agent turn static knowledge (docs, repos, architecture, decks) into work people actually adopt. It checks the culture first (Schein assumptions, Edmondson safety, Scientist Mode), then compresses the message (Minto, Dirksen, Knowles), then plans how adoption moves through the network (Centola, Jackson, Berger REDUCE, cascades). The same cognitive engine also structures written and projected artifacts: blog posts (technical and financial), a thesis, journal article, or slides, with a skeleton grid, headlines, bullets, emphasis, writing advice, style guidance, and keywords before prose (Belcher, Cron, Kolin, Graff & Birkenstein, Klinkenborg, Williams & Bizup). Use it for rollouts, buy-in, change management, briefings, resistance, onboarding, or to structure a piece of writing where the knowledge is there but the structure keeps getting lost. Skip it for factual lookup or single-fact Q&A.
|
COBESY: Cognitive Behavioral Systemic
COBESY turns static knowledge into something an organization can use. A document
does not change much by itself. People change when the idea is framed safely,
made easy to understand, and routed through the parts of the network that others
trust.
Static knowledge -> COBESY compiler -> operational skill
(Docs, repos, architecture) -> (layered stack engine) -> (adoption, agendas, buy-in)
This skill is for the messy part after the deck exists. It avoids chronological
agendas, all-hands blasts, icebreakers, and pressure campaigns. It uses nine
source works on culture, networks, learning, and influence. See
references/source-map.md for the bibliography and substitutions.
The same Cognitive engine has a second output. Instead of a live agenda it can
structure a written or projected piece: a blog post, a thesis, slides, or a
journal article. By default, this path emits a first-pass composition_blueprint:
a skeleton grid with headlines, bullets, emphasis, writing advice, style
guidance, audience-leading cues, and keywords to use. Do not write the article,
paper, or slide prose unless the user explicitly asks for prose or a full draft.
See references/composition.md. Use it when the knowledge is there but the
structure keeps getting lost as the material grows.
The execution stack
Read it top-down, because that is what the audience experiences. Run it
bottom-up, because culture decides whether anything sticks:
┌──────────────────────────────────────────────────────────────┐
│ 3. COGNITIVE INTERFACE Minto · Dirksen · Knowles │ ← what they see
│ (compress knowledge to fit working memory + adult learners)│
└───────────────────────────────┬──────────────────────────────┘
▼
┌──────────────────────────────────────────────────────────────┐
│ THE COBESY COMPILER (this agent) │
│ translates compressed hierarchies into execution skill │
└───────────────────────────────┬──────────────────────────────┘
▼
┌──────────────────────────────────────────────────────────────┐
│ 2. BEHAVIORAL VECTOR Centola · Jackson · Berger · cascades │ ← how it spreads
│ (engineer the transmission path for voluntary adoption) │
└───────────────────────────────┬──────────────────────────────┘
▼
┌──────────────────────────────────────────────────────────────┐
│ 1. SYSTEMIC BASE Schein · Edmondson · Scientist Mode │ ← whether it survives
│ (map + neutralize the hidden rules of the organization) │
└──────────────────────────────────────────────────────────────┘
Run order: Systemic → Cognitive → Behavioral → Assemble → Validate.
You diagnose the ground (systemic) before you compress the message (cognitive)
before you route it through people (behavioral). The cognitive layer sits at the
top of the stack the audience experiences, but it is compiled second, because
content that ignores the culture gets rejected regardless of how clear it is.
The three compiler inputs
Map the work to these three inputs. If one is missing, ask for it or say exactly
what you are inferring in Phase 0.
| Input | Question it answers | Feeds layer | Output artifact |
|---|
raw_knowledge | What are we transferring? (docs, repo, decision, tool) | Cognitive | agenda_structure or composition_blueprint |
cultural_assumptions | Where are we landing it? (hidden rules, safety level) | Systemic | framing_protocol |
network_topology | Through whom does it spread? (anchors, clusters) | Behavioral | target_nodes |
The Cognitive layer has two back-ends off the same Minto hierarchy. The default
emits agenda_structure for a live session. When the deliverable is a piece of
writing, the composition back-end emits composition_blueprint instead; the
Behavioral layer is then optional (a thesis has readers, not a rollout).
The AISkillCompiler mental model and the legacy-vs-COBESY comparison live in
references/compiler.md.
When to use / when not
Use it when the goal is to make an organization do something with knowledge:
roll out a tool/process, get buy-in, design an agenda or briefing, overcome
resistance, make something stick, onboard a team, plan a change.
Do not load it for factual lookup, a single-fact answer, or a task with no human
adoption problem. If nobody needs to change behavior, COBESY is overhead.
The COMPILE workflow
Phase 0: Intake
Gather the three inputs. Then state these in one line each:
- Target behavior: the specific action you want a named group to take. Not "awareness". An action.
- Hidden assumption: one suspected rule that governs this group (Schein).
- High-leverage anchor: one person or group whose adoption would pull others (Jackson).
If you cannot name the target behavior as an observable action, stop and fix
that first. Use assets/diagnostic-intake.md.
Phase 1: Systemic filter (the ground)
Run the audience through references/01-systemic-layer.md.
- Map artifacts -> espoused values -> basic underlying assumption (Schein).
- Locate the org on the Edmondson safety × accountability 2×2.
- Produce
framing_protocol: how to frame this work as a learning problem,
what not to say, and an explicit disproof condition ("we are wrong if ___").
- Gate: if the org sits in the Anxiety quadrant (low safety / high
accountability), raise safety before pushing content. Do not skip.
Phase 2: Cognitive compression (the message)
Run raw_knowledge through references/03-cognitive-layer.md.
- Build a Minto pyramid: lead with the conclusion, group support MECE, open
with SCQA.
- Cut to working-memory limits and speak to motivation as well as analysis (Dirksen's Elephant and Rider).
- If the audience is senior/expert, apply Knowles andragogy (respect experience,
problem-centered, self-direction).
- Produce
agenda_structure: a top-down hierarchy, not a chronological list.
If the deliverable is a written or projected piece, run the same hierarchy
through the composition back-end in references/composition.md instead. It sorts
the work by four grains (macro governing idea, opening, paragraph move, sentence),
adapts to the format (blog, thesis, slides, journal article), and emits a
first-pass composition_blueprint via assets/composition-blueprint.md. Default
to a skeleton grid: headlines, bullet points, emphasis guidance, writing advice,
style guidance, audience-leading cues, and keywords to use. Avoid marketing
language. Do not draft the article, paper, or slide prose unless the user
explicitly asks for a draft, prose, final copy, or full article.
Phase 3: Behavioral sequencing (the path)
Run the rollout through references/02-behavioral-layer.md.
- Classify the change: simple contagion (info) or complex contagion (costly
behavior change). Most adoptions are complex, so they need wide bridges, not broadcasts.
- Pick targets by centrality (Jackson): eigenvector anchors for cascades.
- Design clustered seeding (Centola): adjacent trusted team adopts first.
- Remove barriers with REDUCE (Berger) instead of pushing harder.
- Sequence respected, objective voices first to start a positive cascade.
- Produce
target_nodes: who adopts in what order, through which clusters.
Phase 4: Assemble & facilitate
Emit the three artifacts (framing_protocol, agenda_structure, target_nodes)
into the relevant templates in assets/. If a live session is needed, pick
exercises from references/facilitation-games.md (Gamestorming), respecting the
open→explore→close shape. Hand the user the matching prompts from
assets/prompt-library.md.
Phase 5: Validate (anti-cringe gate)
Before delivery, run every artifact through the validation gate in
references/compiler.md:
| Check | Layer | Fail action |
|---|
| MECE? | Cognitive | Regroup the pyramid |
| Within working memory? | Cognitive | Chunk / add job aid |
| Delivered at the point of action? | Cognitive | Embed it / make an in-workflow job aid |
| Safe enough to say? | Systemic | Reframe / raise safety first |
| Disproof condition stated? | Systemic | Add falsifiability or reject item |
| Cascade, not broadcast? | Behavioral | Re-sequence through clusters |
| Removes barriers vs pushes? | Behavioral | Switch to REDUCE |
If any check fails, return to that layer. Do not ship around a failed gate.
For a composition_blueprint, also run the writing linter in
references/composition.md (first-paragraph drop-off, info overload, mismatched
TOC, scope creep, flat exposition, expert fog, sentence sprawl, reader mismatch,
AI slop / generic voice). Same rule: a failed check sends you back to the grain
that owns it.
If the user explicitly asked for prose, run the humanizer pass before delivery.
Drafted prose must pass these output conditions:
- no significance inflation, vague authority, forced trios, generic upbeat endings, or chatbot phrasing;
- no AI-looking output symbols: em dashes, curly quotes, emoji decoration, emoticons, decorative bold, or chatbot-style visual formatting unless the user explicitly asks for them;
- sentence rhythm varies without turning cute or over-written;
- the author's voice, reader level, and tolerance for detail are preserved;
- the agent can answer "what still makes this sound AI-generated?" and repair the answer.
Decision points
- Simple vs complex contagion: broadcast is fine only for simple info;
anything costly/risky/identity-relevant needs clustered wide bridges.
- Low psychological safety: systemic layer first; content is wasted in the
Anxiety quadrant.
- High resistance / reactance: switch from persuasion to Berger's REDUCE
(remove the barrier; pushing harder backfires).
- Senior or expert audience: lead with Knowles (their experience is the
curriculum; never treat them as empty vessels).
Cross-skill handoffs
COBESY handles adoption. It takes a knowledge asset or decision and turns it
into a path for action. It does not render draw.io diagrams, so it sends analysis
to the visualization skills and pulls verified inputs from the analysis skills.
Keep actor, cluster, and assumption names stable across skills so the artifacts
line up. Map each handoff to a COMPILE phase:
| Sibling skill | Direction | Phase | What flows |
|---|
reflect | in | Phase 0 | Turn a vague "drive adoption of X" request into a clear prompt with the three compiler inputs before COMPILE starts. |
strategic-foresight-viz | in | Phase 0–2 | Import PESTLE drivers / scenarios as the Complication in the SCQA opener: the external reason the change is needed now. |
intana-viz | both | Phase 1–3 | Render the diagnostics: Schein Cultural Web, Edmondson 2×2, stakeholder / network maps, the Minto agenda pyramid, the adoption map. Route a contested framing_protocol assumption through Key Assumptions Check, Red Teaming, or Pre-Mortem and bring the verified version back. |
premortem | both | Phase 3–5 | Stress-test the assembled target_nodes rollout: assume the adoption failed, reason backward, then feed the failure modes back into REDUCE barriers and the framing protocol. The Phase 5 anti-cringe gate is a lighter inline version of this. |
game-theory-negotiation | both | Phase 3 | When buy-in needs a bargain (resourcing, mandate, an anchor's commitment), hand the named eigenvector anchor and the incentive question to the negotiation skill; bring back a concession plan and incentive-compatible profit-share / bonus sizing for the adoption design. |
humanizer | out | Phase 4 / Phase 5 | Clean the emitted brief, agenda, or composition output so the deliverable reads human, not AI-generated. This is the writing-level companion to COBESY's structural anti-cringe gate. |
Rule of thumb: analysis skills verify the inputs, viz skills draw the artifacts,
COBESY sequences the adoption. A premortem surfaces a barrier →
COBESY routes around it; a negotiation secures an anchor → COBESY seeds from it;
intana-viz renders the cultural map → COBESY frames against it.
Use the shared context packet. The sibling skills pass a common packet with
stable IDs (A1 buyer, S2 recession case, …) so artifacts cross-reference;
see game-theory-negotiation/references/drawio-concepts.md. COBESY reads and
writes the same fields rather than inventing parallel names:
| Packet field | COBESY role |
|---|
Assumptions | COBESY is a primary producer. Schein basic underlying assumptions become packet assumptions; route contested ones through intana-viz to verify. |
Actors | COBESY annotates actors with network role: eigenvector anchor, bridge, seed cluster. Keep actor IDs identical to the negotiation/investigation diagrams. |
Scenarios | Consumed from strategic-foresight-viz as the SCQA Complication. |
Constraints | The framing protocol's "safe to say" limits and disproof conditions are cultural constraints. |
Open questions | Each disproof condition ("we are wrong if ___") is an open question other skills can pick up. |
Files
References, load as needed:
references/compiler.md: the compiler contract, I/O, legacy-vs-COBESY, validation gate.references/01-systemic-layer.md: Schein, Edmondson, Scientist Mode -> framing_protocol.references/02-behavioral-layer.md: Centola, Jackson, Berger, cascades -> target_nodes.references/03-cognitive-layer.md: Minto, Dirksen, Knowles -> agenda_structure.references/composition.md: the writing back-end (Belcher, Cron, Kolin, Graff & Birkenstein, Klinkenborg, Williams & Bizup) -> composition_blueprint.references/facilitation-games.md: Gamestorming exercises per phase.references/source-map.md: bibliography, layer mapping, substitutions.
Templates, fill and deliver:
assets/diagnostic-intake.md: Phase 0 intake.assets/change-brief.md: the assembled three-artifact deliverable.assets/agenda-pyramid.md: Minto agenda skeleton.assets/adoption-map.md: Centola/Jackson rollout plan.assets/composition-blueprint.md: first-pass messaging skeleton for written or projected pieces (blog, thesis, slides, journal article).assets/prompt-library.md: ready prompts to drive the agent per layer.
