The Agentic
Operating Model for Education.

You are setting up an Obsidian vault to act as the human-facing knowledge layer for a Malaysian Private Education Provider multi-agent operating system. The 5 specialist agents are Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent; the orchestrator is Chief of Staff. The Group CEO reads from this vault every morning.

Generate the vault structure:
- Folder hierarchy: /agents (one folder per agent code), /decisions, /playbooks, /learned-context, /regulatory, /operations, and the Private Education Provider-specific entity folders for: programmes, students, faculty, campuses, accreditations.
- Frontmatter schemas (YAML) for each note type: decision, playbook, agent-writeback, entity-profile, regulatory-change, outcome.
- Tag taxonomy: priority::P0/P1/P2/Esc, agent::(Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent), status::approved/deferred/escalated, outcome::win/loss/pending, regulator::(MOE / MQA / JPN / EMGS / PDPA).
- Dataview queries the Group CEO uses at 06:00 daily: (a) today's Decision List, (b) this week's escalations, (c) agent-by-agent RM-impact tally, (d) decisions whose outcome::pending is more than 7 days old.

Output a clear directory tree + one fully written sample note per note type (6 notes) with realistic Private Education Provider-flavoured content.

Design the Pinecone vector index that backs the agents' shared memory for the Private Education Provider system from the previous prompts. The agents are Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent (plus Chief of Staff orchestrator). Scale: multi-campus group (~24,000 active learners, 8 campuses).

Requirements:
- One Pinecone namespace per agent (Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent) plus a shared 'orchestrator' namespace and a 'regulatory' namespace.
- Vector dimensions: 3072 (Voyage 3 large or OpenAI text-embedding-3-large). Justify whether to downscale to 1024 (matryoshka) for cost.
- Per-vector metadata fields: doc_id, agent (one of Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent | Chief of Staff | regulatory), entity_type (one of programmes, students, faculty, campuses, accreditations), entity_id, ts (unix), decision_class (forecast | decision | playbook | outcome | regulatory-change), priority, rm_impact (signed float), outcome (win | loss | pending), tags (array).
- Hybrid retrieval: sparse + dense. Include BM25 for exact lookup of entity IDs (Private Education Provider-specific codes — e.g., branch IDs, project codes, SKU codes, tower IDs).
- Settings: serverless vs pod-based — recommend one for multi-campus group (~24,000 active learners, 8 campuses). Justify replica count and metadata-index choice.
- Chunking: 512-token windows, 64-token overlap, but also one vector per H2/H3 section so the agents can cite a specific section back to the Group CEO.

Output as: (a) a Terraform module that provisions the index, (b) a Python pinecone-client setup script that creates the namespaces, (c) a JSON schema validator for the metadata fields, ready to enforce on every upsert.

Build the embedding and ingestion pipeline that turns Obsidian markdown notes into Pinecone vectors for the Private Education Provider agents (Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent, Chief of Staff).

Pipeline:
1. File watcher on the vault folder (chokidar in Node or watchdog in Python) that fires on save and on git-pull.
2. Parse YAML frontmatter and markdown body via python-frontmatter or gray-matter.
3. Chunk body by H2/H3 boundaries AND by ~512-token windows with 64-token overlap. Preserve heading path as chunk.section_path metadata.
4. Embed via Voyage 3 large (or text-embedding-3-large) — async, batched at 100 items, retry with exponential backoff on 429/5xx.
5. Extract metadata: agent_namespace (from path /agents/<code>/...), entity links (parse [[wikilinks]] from body and map to entity_id), decision_class (from frontmatter), regulatory mentions (regex hit on MOE / MQA / JPN / EMGS / PDPA), rm_impact (from frontmatter), outcome (from frontmatter).
6. Upsert with deterministic IDs: sha256(file_path + chunk_index). Delete-then-upsert on save to avoid stale chunks.
7. Write back to the note's frontmatter: pinecone_ids[], last_embedded_at, chunk_count. Commit back to git for auditability.

Deliverables:
- A Python repo (FastAPI + Pinecone client + Voyage client + python-frontmatter + watchdog) with a docker-compose.yml that starts the watcher and a small admin UI for the Group CEO's chief of staff to trigger re-embed on stale notes.
- An on-failure alerter that posts to Slack/Telegram if any sub-step errors out twice in a row.

Build an MCP (Model Context Protocol) server that exposes the Private Education Provider Obsidian vault + Pinecone index as queryable tools for the agents (Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent) and Chief of Staff.

Expose these tools:
- search_memory(query, agent_namespace?, entity_type?, entity_id?, date_range?, top_k=10) — hybrid Pinecone retrieval; returns chunks with source-note paths, section_path, and frontmatter metadata.
- get_decision_history(entity_id, days=30) — returns every Daily Decision List entry that touched this programmes or other entity.
- get_playbook(name) — returns the most up-to-date playbook for a named scenario. Known playbooks for this industry include: admissions-yield playbook, programme-discontinuation diligence, MQA-audit playbook.
- get_agent_writeback(agent_code, since) — returns recent forecasts/decisions written by one agent.
- get_outcome(decision_id) — returns the actual outcome of an approved decision; used by the nightly Chief of Staff retraining loop.
- write_note(path, frontmatter, body) — writes a new markdown note to the vault (triggers re-embedding via the Step-3 watcher).
- propose_playbook_update(playbook_name, diff, evidence_decision_ids) — drafts a markdown PR to the playbook with linked evidence.

Implement as a TypeScript MCP server using @modelcontextprotocol/sdk. Configure manifests for: (a) Claude Desktop, (b) Claude Code, (c) n8n's MCP node so the agents can call it as part of the cascade. Output the full source code + a 1-page how-to-install.

Wire up the nightly knowledge-graph sync from production operations to the Obsidian vault and Pinecone for the Private Education Provider multi-agent system (Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent, Chief of Staff).

Each night at 02:00 MYT:
1. Pull yesterday's outcomes from production: for each Daily Decision List entry, fetch what the Group CEO actually approved / deferred / escalated, the realised RM-impact, and any downstream effect.
2. Stamp outcomes onto each decision note's frontmatter (outcome::win | loss | pending, actual_rm_impact, time_to_outcome).
3. Generate a 'daily writeback' note per agent (Admissions Agent, Curriculum Agent, Faculty Agent, Campus Agent, Programme Agent) summarising what it saw, what it recommended, what was approved, and the delta vs forecast. Save under /agents/<code>/writeback/YYYY-MM-DD.md.
4. For every new or updated note, the Step-3 pipeline re-embeds and upserts to Pinecone.
5. Run a "lessons learned" extractor: prompt the Chief of Staff model with the day's outcomes and ask for 3-5 playbook updates. Append as drafts to /playbooks/_drafts/ for Group CEO review.
6. Push a Slack/Telegram digest to the Group CEO's chief of staff: the top 5 lessons, plus any decisions stuck at outcome::pending for >7 days.

Deliverables: (a) an n8n workflow JSON, (b) a Claude Code skill, or (c) a Python cron job — pick the best fit for a multi-campus group (~24,000 active learners, 8 campuses) and explain why. Include error handling, retry, and a fail-open mode that alerts a human on any failure.