The Knowledge Work Agent Engine: A File-Based Stack for PM, Leadership, and Marketing (Not Just Code)

Knowledge Work Engine Series (Part 0 — hub)
Next: Part 1 — Project management · Part 2 — Leadership · Part 3 — Marketing & voice
Foundation: External Memory Series · Harness memory loop

What is a knowledge work agent engine?

A knowledge work agent engine is a file-based operating system for AI-assisted PM, leadership, and marketing. It is not a chatbot plugin. It combines four memory tiers, a routing policy (WORK-ROUTING.md), session footers, optional batch workers, and (for content) a voice layer—so every assistant session reads the same handoff files instead of reinventing context.

Who it is for: program managers, team leads, and marketers who already use Jira, a wiki, or a task app and want AI output that stays aligned with sprint goals, decisions, and brand voice.

What you will learn: how the engine complements Agile and Confluence; how to set it up in one folder with any AI tool; and where Part 1, Part 2, and Part 3 go deeper.

Who this is for — and what it does not replace

Part 1 goes deeper on complex scope, documentation drift, and review before publish.

How to get started

This is not a product you install. It is a folder of markdown files plus a habit: tell the AI which files to read at session start, and write one line when you stop.

Below: how I run it (full example), then easier paths if you are not ready for an IDE stack.

Example implementation — how I run it

I use one folder per active project—an Obsidian vault slice or git repo—and open that folder as a Cursor workspace. The agent reads and edits markdown in place. I do not dump my whole drive or Jira export into chat; I curate a small handoff set and link out to execution tools.

1. Dual vault layout

Knowledge-work projects use the same idea: Operations/AI Session Bridge.md, Initiatives/<client>/Bridge.md, System/Profile/voice-guide.md. Code projects add Features/, AGENTS.md, and repo handoff files. Details for builders: External Memory Part 1.

2. Scaffold once per project

I paste the replication kit prompt into Cursor and let the agent create the file tree and starter content. That takes one session—not ongoing maintenance.

3. Layer 4 — what makes bootstrap automatic

This is not a Cursor skill or Custom GPT by default. It is files + rules. Skills and Custom GPTs are optional packaging of the same bootstrap.

4. My session loop

1. Start — Rules (and hook if enabled) point the agent at Layer 2: AI Session Bridge, initiative Bridge, last lines of Session Summaries, voice-guide when drafting prose.
2. Work — Agent edits curated markdown; Jira/Confluence stay authoritative for tickets and published narrative.
3. Close — One line in Session Summaries; update Bridge if priority shifted; footer block (what changed, memory paths, next action).

Next Monday: new chat, same reads, caught up in seconds from disk—not vendor memory.

Pinch or ⌘/Ctrl+scroll to zoom · drag when zoomed · tap image for full screen

Proof elsewhere on this site: Obsidian second brain · Harness memory loop.

My stack vs the minimum

Start here if you are new (you do not need my stack)

Three questions:

• Do you ship code in this folder? → Consider Path C after Path A works.
• Only PM, leadership, or marketing? → Path A or Path B.
• Tired of pasting every session? → Graduate to Path C; see External Memory Part 1.

What you are building

Where files live (hosts, not dogma)

Continuity = files you update when you stop, not which app hosts them.

Path A — Chat only (30 minutes)

Step 1 — Create one folder (~/KnowledgeWork/ or an Obsidian vault).

Step 2 — Create three files (or run the replication kit once):

KnowledgeWork/
  Operations/
    AI Session Bridge.md
    Session Summaries.md
  Initiatives/<YourProject>/Bridge.md
  System/Profile/voice-guide.md   ← skip if not writing content yet

Step 3 — Starter prompt (paste into any AI):

Read these files in order, then reply with a 4-line kickoff (objective, top open loop, risk, first action):
1. Operations/AI Session Bridge.md
2. Initiatives/<YourProject>/Bridge.md
3. Operations/Session Summaries.md (last 5 lines only)

Do not invent facts not in the files. If a file is missing, say so.

Step 4 — Close: one line in Session Summaries; update Bridge if priority moved.

If session four needs less re-explanation, the engine works. Do not add Cursor, MCP, or extra agents until then.

Path B — Notes vault + paste

Same files as Path A inside Obsidian (or Logseq). Use wikilinks between Bridge and _Home. Still paste the starter prompt until you adopt Path C.

Path C — IDE workspace

My path above: open project folder in Cursor, scaffold with replication kit, add .cursor/rules + MCP + optional hooks. Builder walkthrough: How I start a new codebase.

Starter file tiers

First session: two prompts

My setup (Cursor) — rules already point at bootstrap; say: "Follow session protocol. Read Bridge and Session Summaries; 4-line kickoff."

Starter (any chat) — use the Path A paste block above.

What to put in the folder (and what to leave out)

How continuity works (session to session)

Other ways to run the same files

After Path A works

• Full scaffold: replication kit
• PM / Jira: Part 1
• Builders: External Memory Series

The problem: chat is not a program office

Project management, leadership, and marketing all produce durable artifacts: decisions, briefs, stakeholder updates, brand copy, editorial calendars. Chat produces scrollback.

When the assistant forgets last week's priority, the failure is usually not model quality. It is no inspectable handoff surface between sessions, tools, and people. Product memory inside one vendor does not travel to your IDE, a teammate's chat tab, or next quarter's you.

A file-based engine (folders + markdown in Obsidian, Logseq, a git repo, or any wiki that exports plain text) can run the same patterns used for AI-assisted software work: four memory tiers, a routing policy, session footers, and optional batch workers. The same structure runs non-coding work when you swap code artifacts for initiative, decision, and editorial files—and add a voice layer for consistency.

This page is the map and the replication kit. Structured so you—or an AI pointed at this article—can scaffold the same system in one afternoon.

Why it matters (four outcomes)

The engine does not replace judgment. It records judgment in files the next session can read.

Where this sits among PM frameworks

Agile, Scrum, Kanban, and phase-gate programs already define execution (Jira), narrative (Confluence), and ceremony. None of them define what an AI assistant must read at session start.

Part 1 is the deep dive on iron triangle, Jira, Confluence, and applied AI routing. Parts 2–3 cover leadership commit modes and marketing voice.

Golden Circle across the series (Sinek)

Simon Sinek's Why → How → What appears in all three domain playbooks:

The memory loop feeds lessons from What back into How (Layer 4) and, when strategic, Why (Layer 3).

What the engine is (six components)

Think of six modules. Software teams often implement them with files like routing-policy.md and context-pack.md (names vary). Knowledge work uses the same logic with different filenames.

Example component chain (diagram syntax below is D2; redraw in Mermaid, Excalidraw, Figma, or a slide deck—the relationships matter more than the tool.)

Pinch or ⌘/Ctrl+scroll to zoom · drag when zoomed · tap image for full screen

1. Memory tiers (four layers)

Same model as the External Memory Series. Short version:

Promotion rule: If you explained a fact twice, promote it from L2 to L3. If a mistake repeated twice, promote a fix to L4.

2. Routing policy (WORK-ROUTING.md)

Mirrors the routing discipline in lightweight agent harnesses: do not load everything for a small question.

3. Session contract (footer modes A–G)

Every work reply: session context at the top (what was read, current priority), footer at the bottom (what changed, where memory was written, what's next).

For knowledge work, interpret modes loosely:

Canonical spec: session footer contract (define your own modes A–G or a shorter shape—the point is a fixed closing block).

4. Voice layer (Layer 3 evergreen)

Coding stacks often skip voice. Marketing and leadership cannot.

Minimum file: System/Profile/voice-guide.md

Point every content-producing agent at this file before drafting.

5. Quality gates

6. Tool connectors

Files are the contract—not Claude memory, not ChatGPT threads. Connect via:

• Paste bootstrap at session start (lowest friction)
• Filesystem MCP or API read (IDE agents)
• Custom instructions block pointing at file paths

Coding → knowledge work translation

Replication kit (give this to an AI)

Copy the block below into any assistant with write access to your knowledge base (Obsidian vault, git repo, SharePoint library, etc.). I use this prompt in Cursor to scaffold a new project folder in one pass. It creates a minimum viable engine—not chat advice.

Prompt: scaffold the knowledge work engine

You are building a file-based knowledge work engine. Create the following structure and fill each file with the template content provided. Use my knowledge-base root: <ROOT> (folder path or vault URI).

## Folder scaffold

<ROOT>/
  System/
    Profile/
      context.md          # role, active domains, quarter focus
      preferences.md      # how AI should behave (brief bullets)
      voice-guide.md      # tone, banned words, claim rules
    _session_startup.md   # bootstrap prompt (paths only, no duplicated content)
  Operations/
    AI Session Bridge.md  # current priority, open loops, next action
    Session Summaries.md  # one line per work block
    Open Loops.md
    WORK-ROUTING.md       # routing table (see template)
  Initiatives/
    _template/
      Bridge.md           # per-initiative handoff
      _Home.md              # evergreen scope for one initiative
  Decisions/
    _template-decision.md
  Editorial/              # skip if not doing content
    00-writing-guide.md   # or link to existing guide

## WORK-ROUTING.md template

| Situation | Route | Memory to load | Footer mode |
|-----------|-------|----------------|-------------|
| Quick question | Direct | None | A |
| One deliverable | Direct | Bridge + relevant L3 | B or C |
| 3+ parallel tracks | Batch orchestrator | Bridge + context-pack once | C |
| Record decision | Decision workflow | Decisions template | D |
| Publish content | Editorial pipeline | voice-guide + writing guide | D |

Rules:
- Do not paste full chat history into sub-prompts.
- End every work session with Session Summaries one-liner + footer.
- Promote facts explained twice from L2 to L3.

## voice-guide.md minimum (10 bullets)

1. First person for my actions and setup (I/my, not my name in third person).
2. No hedge words: actually, honestly, basically, clearly.
3. No corporate filler: leverage, synergy, landscape.
4. Tables for reference; 2-4 sentence paragraphs.
5. No statistics without source.
6. No first-person field stories unless human verified.
7. Name the decision owner and date in leadership docs.
8. American English.
9. Session end: offer to update Bridge and Open Loops.
10. Link related notes; no orphan captures.

## Bootstrap block (_session_startup.md)

At session start, read in order:
1. System/Profile/context.md
2. System/Profile/preferences.md
3. System/Profile/voice-guide.md
4. Operations/AI Session Bridge.md
5. Operations/Session Summaries.md (last 5 lines)
6. Today's daily note if present

Produce 4-line kickoff: objective, urgent open loop, risk, first action.

After creating files, confirm paths and suggest one 15-minute test task.

File templates (human or AI)

Operations/AI Session Bridge.md

# AI Session Bridge

## Current priority
<one line>

## Open loops
- [ ] ...

## Next physical action
<one line>

Initiatives/_template/Bridge.md

# <Initiative name> — Bridge

## Status
<green / amber / red + one line>

## This week
1. ...

## Blockers
- ...

## Decisions pending
- ...

## Links
- Evergreen: [[_Home]]

Decisions/_template-decision.md

# Decision: <title>
Date: YYYY-MM-DD
Owner: <name>
Status: proposed | decided | superseded

## Context
<2-4 sentences>

## Options considered
| Option | Upside | Downside |
|--------|--------|----------|

## Decision
<one paragraph>

## Who was informed
- ...

## Review date
YYYY-MM-DD

Advanced: harness patterns without code

You do not need custom IDE agents for knowledge work. Optional patterns when volume grows:

Subagents do not inherit your rules. Paste worker directives into every dispatch—keep sub-prompts short and never paste full session history (dispatch hygiene).

How the series continues

Myth vs reality (knowledge work AI)

Common mistakes (and fixes)

FAQ

Is this the same as RAG (retrieval-augmented generation)?

No. RAG is a technical pattern (embed documents, retrieve chunks, generate). This engine is an operational pattern: which files humans curate, when agents load them, and how lessons return to Layer 4. You can implement retrieval with RAG tools; the engine defines what must be retrievable.

Do I need Obsidian?

No. Any markdown knowledge base works: git repo, Logseq, Notion export, SharePoint library. Obsidian is one example.

Does this replace Jira or Confluence?

No. Jira owns execution. Confluence owns published narrative. The engine owns agent bootstrap and session continuity.

How is this different from ChatGPT memory or Custom GPTs?

Vendor memory is opaque and siloed. Files are portable, inspectable, and shared across Claude, Cursor, and teammates.

Can I point an AI at this article to build the system?

Yes. Use the replication kit prompt. Output should be files, not chat advice.

Where does this connect to the External Memory Series?

Same four tiers. This series applies that model to PM, leadership, and marketing with domain routing. Start with the External Memory hub if tiers are new.

Should I let the AI read my entire project folder?

No. Curate a handoff set (typically 4–6 files at session start). Link to Jira, Confluence, or large archives—do not mirror whole backlogs in markdown. See How to get started.

Do I need Cursor, MCP, or custom agents?

No for day one. Any chat tool works with Path A paste bootstrap. Cursor, MCP, and hooks are my Path C—optional accelerators. See Example implementation vs Path A.

How does continuity work if every chat is new?

Files are the memory. Session Summaries.md and Bridge.md are updated when you stop; the next session reads them cold. Vendor "memory" is optional and not portable.

Limitations

• File memory needs a five-minute session close habit or an agent following End of Session protocol.
• Over-documentation kills adoption. Use the promotion rule.
• Voice guides do not replace human review for sensitive leadership comms.
• Tool behavior changes; re-verify bootstrap paths after IDE upgrades.
• Does not auto-sync Jira/Confluence or replace formal peer-review tools — it gives structure, gates, and RACI hooks you can attach to existing review habits (Part 1).

Reader action

If you are starting from zero: Path A — chat only or run the replication kit once. Do not add tools first.

If you already use a markdown knowledge base: Add WORK-ROUTING.md and voice-guide.md. Link from External Memory Part 2.

If you want my full stack: Example implementation then Path C.

If you are an AI builder: Treat Part 0 as spec. Parts 1–3 are worked examples. Output should be files, not chat.

Sources

• External Memory Series hub
• Obsidian memory for personal productivity
• Cursor harness memory loop
• Deliberate file memory / governance