{ "nbformat": 4, "nbformat_minor": 5, "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python", "version": "3.13.0" }, "blog_metadata": { "topic": "How Copilot Notebooks and Multimodal Capture Could Reshape Executive Knowledge Work", "slug": "how-copilot-notebooks-and-multimodal-capture-could-reshape-e", "generated_by": "LinkedIn Post Generator + Azure OpenAI", "generated_at": "2026-06-19T17:58:49.873Z" } }, "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# How Copilot Notebooks and Multimodal Capture Could Reshape Executive Knowledge Work\n", "\n", "This notebook turns the blog post into a hands-on validation workflow. It focuses on the core claim: the value of Copilot Notebooks is less about note-taking and more about governed context assembly, grounded synthesis, citations, and workflow-safe outputs for executive decision support.\n", "\n", "The examples below use Python to simulate architecture patterns, governance checks, multimodal capture normalization, and briefing generation. Where the blog referenced hypothetical or illustrative endpoints, this notebook keeps those examples safe and runnable by using mock data and optional live-call templates." ] }, { "cell_type": "code", "metadata": {}, "source": [ "%pip install -q requests pandas matplotlib networkx" ], "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": {}, "source": [ "import os\n", "import json\n", "from typing import Any, Dict, List\n", "\n", "import requests\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import networkx as nx" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Working model: from executive request to governed synthesis\n", "\n", "The blog argues that the notebook itself is not the main innovation. The bigger shift is a governed context layer that can retrieve approved enterprise signals, synthesize them with citations, and deliver usable outputs such as risks, decisions, and follow-ups.\n", "\n", "This cell converts that conceptual flow into a graph you can inspect." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import matplotlib.pyplot as plt\n", "import networkx as nx\n", "\n", "nodes = [\n", " \"Executive asks for briefing\",\n", " \"Copilot Notebook\",\n", " \"Grounded retrieval from approved M365 context\",\n", " \"Email, Teams, Files, Meetings, CRM connectors\",\n", " \"Multimodal capture: voice, screenshots, whiteboards, docs\",\n", " \"Structured synthesis\",\n", " \"Action items, risks, decisions, follow-ups\",\n", " \"Executive briefing app or dashboard\",\n", "]\n", "\n", "edges = [\n", " (nodes[0], nodes[1]),\n", " (nodes[1], nodes[2]),\n", " (nodes[2], nodes[3]),\n", " (nodes[3], nodes[4]),\n", " (nodes[4], nodes[5]),\n", " (nodes[5], nodes[6]),\n", " (nodes[6], nodes[7]),\n", "]\n", "\n", "G = nx.DiGraph()\n", "G.add_nodes_from(nodes)\n", "G.add_edges_from(edges)\n", "\n", "plt.figure(figsize=(14, 8))\n", "pos = nx.spring_layout(G, seed=42, k=1.2)\n", "nx.draw_networkx_nodes(G, pos, node_size=3500, node_color=\"#DCEBFA\")\n", "nx.draw_networkx_edges(G, pos, arrows=True, arrowstyle=\"-|>\", arrowsize=20, edge_color=\"#4A6FA5\")\n", "nx.draw_networkx_labels(G, pos, font_size=9)\n", "plt.title(\"Executive Knowledge Work Flow: Capture -> Grounding -> Synthesis -> Delivery\")\n", "plt.axis(\"off\")\n", "plt.show()" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Required environment variables for token acquisition\n", "\n", "If you want to test the client credentials pattern against Microsoft identity, set these variables first:\n", "\n", "- `TENANT_ID`\n", "- `CLIENT_ID`\n", "- `CLIENT_SECRET`\n", "\n", "The next code cell safely checks for them and only attempts a live request if they are present." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: acquire an access token for a custom executive briefing app\n", "\n", "The original blog included a token acquisition example using client credentials. This version is runnable and defensive: it validates required environment variables and avoids failing noisily when secrets are not configured." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import os\n", "import requests\n", "\n", "required = [\"TENANT_ID\", \"CLIENT_ID\", \"CLIENT_SECRET\"]\n", "missing = [k for k in required if not os.environ.get(k)]\n", "\n", "if missing:\n", " print(\"Skipping live token request. Missing environment variables:\", \", \".join(missing))\n", " access_token = None\n", "else:\n", " tenant_id = os.environ[\"TENANT_ID\"]\n", " client_id = os.environ[\"CLIENT_ID\"]\n", " client_secret = os.environ[\"CLIENT_SECRET\"]\n", "\n", " token_url = f\"https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token\"\n", " payload = {\n", " \"client_id\": client_id,\n", " \"client_secret\": client_secret,\n", " \"scope\": \"https://graph.microsoft.com/.default\",\n", " \"grant_type\": \"client_credentials\",\n", " }\n", "\n", " response = requests.post(token_url, data=payload, timeout=30)\n", " response.raise_for_status()\n", " access_token = response.json()[\"access_token\"]\n", " print(access_token[:40] + \"...\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Required environment variables for the grounded synthesis request\n", "\n", "To test the optional live request template below, set:\n", "\n", "- `ACCESS_TOKEN`\n", "\n", "The endpoint shown in the blog is illustrative rather than a guaranteed current production endpoint. The code therefore supports both a mock path and an optional live-call path." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: grounded synthesis request for an executive briefing\n", "\n", "The blog's central pattern is a bounded request: explicit users, explicit sources, a time window, and citation-friendly output. This cell preserves that design but defaults to a mock response so the notebook remains executable without tenant-specific setup." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import json\n", "import os\n", "import requests\n", "\n", "body = {\n", " \"prompt\": \"Summarize strategic risks, customer escalations, and open decisions for this week.\",\n", " \"context\": {\n", " \"users\": [\"ceo@contoso.com\"],\n", " \"sources\": [\"mail\", \"teamsChats\", \"sharePoint\", \"meetings\"],\n", " \"timeRange\": {\"start\": \"2026-06-12T00:00:00Z\", \"end\": \"2026-06-19T00:00:00Z\"},\n", " },\n", " \"output\": {\"format\": \"bulletSummary\", \"includeCitations\": True},\n", "}\n", "\n", "access_token = os.environ.get(\"ACCESS_TOKEN\")\n", "url = \"https://graph.microsoft.com/beta/copilot/notebooks/briefings:groundedSynthesis\"\n", "\n", "if access_token:\n", " headers = {\"Authorization\": f\"Bearer {access_token}\", \"Content-Type\": \"application/json\"}\n", " try:\n", " response = requests.post(url, headers=headers, data=json.dumps(body), timeout=60)\n", " response.raise_for_status()\n", " synthesis_result = response.json()\n", " print(\"Live response received:\")\n", " print(json.dumps(synthesis_result, indent=2))\n", " except Exception as e:\n", " print(\"Live call failed; falling back to mock result.\")\n", " print(\"Reason:\", e)\n", " synthesis_result = {\n", " \"summary\": [\"Revenue risk in EMEA due to delayed renewals.\"],\n", " \"decisions\": [\"Approve discount exception for top 3 accounts.\"],\n", " \"actions\": [{\"owner\": \"CRO\", \"task\": \"Review renewal blockers\"}],\n", " \"citations\": [{\"title\": \"Q2 Renewal Review\", \"location\": \"SharePoint\"}],\n", " \"sensitivity\": \"Confidential\",\n", " }\n", "else:\n", " synthesis_result = {\n", " \"summary\": [\"Revenue risk in EMEA due to delayed renewals.\"],\n", " \"decisions\": [\"Approve discount exception for top 3 accounts.\"],\n", " \"actions\": [{\"owner\": \"CRO\", \"task\": \"Review renewal blockers\"}],\n", " \"citations\": [{\"title\": \"Q2 Renewal Review\", \"location\": \"SharePoint\"}],\n", " \"sensitivity\": \"Confidential\",\n", " }\n", " print(\"Using mock grounded synthesis result:\")\n", " print(json.dumps(synthesis_result, indent=2))" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: normalize grounded synthesis into a compact executive briefing\n", "\n", "A key theme in the blog is that leaders need usable outputs, not just polished prose. This cell transforms a synthesis result into a compact briefing structure with headline items, decision points, next actions, and evidence." ] }, { "cell_type": "code", "metadata": {}, "source": [ "from typing import Any, Dict, List\n", "\n", "api_result: Dict[str, Any] = {\n", " \"summary\": [\"Revenue risk in EMEA due to delayed renewals.\"],\n", " \"decisions\": [\"Approve discount exception for top 3 accounts.\"],\n", " \"actions\": [{\"owner\": \"CRO\", \"task\": \"Review renewal blockers\"}],\n", " \"citations\": [{\"title\": \"Q2 Renewal Review\", \"url\": \"https://contoso.sharepoint.com/sites/reviews\"}],\n", "}\n", "\n", "briefing: Dict[str, List[str]] = {\n", " \"headline\": api_result.get(\"summary\", []),\n", " \"decision_points\": api_result.get(\"decisions\", []),\n", " \"next_actions\": [f'{a[\"owner\"]}: {a[\"task\"]}' for a in api_result.get(\"actions\", [])],\n", " \"evidence\": [f'{c[\"title\"]} -> {c[\"url\"]}' for c in api_result.get(\"citations\", [])],\n", "}\n", "\n", "for section, items in briefing.items():\n", " print(f\"\\n{section.upper()}\")\n", " for item in items:\n", " print(f\"- {item}\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: convert multimodal capture metadata into notebook-ready signals\n", "\n", "The blog extends beyond meetings and documents to multimodal capture: voice notes, screenshots, whiteboards, and other artifacts. This cell shows how raw capture metadata can be normalized into notebook entries with semantic labels and sensitivity metadata." ] }, { "cell_type": "code", "metadata": {}, "source": [ "captures = [\n", " {\"type\": \"voiceNote\", \"title\": \"Board prep memo\", \"tags\": [\"strategy\", \"risk\"]},\n", " {\"type\": \"image\", \"title\": \"Whiteboard from M&A workshop\", \"tags\": [\"acquisition\", \"synergy\"]},\n", " {\"type\": \"document\", \"title\": \"Customer escalation summary\", \"tags\": [\"customer\", \"priority\"]},\n", "]\n", "\n", "notebook_entries = []\n", "for item in captures:\n", " notebook_entries.append({\n", " \"sourceType\": item[\"type\"],\n", " \"displayName\": item[\"title\"],\n", " \"semanticLabels\": item[\"tags\"],\n", " \"sensitivity\": \"Confidential\",\n", " })\n", "\n", "for entry in notebook_entries:\n", " print(entry)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sequence model: request, retrieval, synthesis, delivery\n", "\n", "The blog also describes a sequence across actors: executive, app, notebook, and approved Microsoft 365 data. This cell renders that interaction as a directed graph so you can validate the control points where provenance and permissions matter." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import matplotlib.pyplot as plt\n", "import networkx as nx\n", "\n", "actors = [\"Executive\", \"Briefing App\", \"Copilot Notebook\", \"Approved M365 Data\"]\n", "messages = [\n", " (\"Executive\", \"Briefing App\", \"Request weekly briefing\"),\n", " (\"Briefing App\", \"Copilot Notebook\", \"Submit grounded synthesis prompt\"),\n", " (\"Copilot Notebook\", \"Approved M365 Data\", \"Retrieve approved context + citations\"),\n", " (\"Approved M365 Data\", \"Copilot Notebook\", \"Emails, meetings, files, chats\"),\n", " (\"Copilot Notebook\", \"Briefing App\", \"Summary, actions, evidence\"),\n", " (\"Briefing App\", \"Executive\", \"Briefing with traceable sources\"),\n", "]\n", "\n", "G = nx.DiGraph()\n", "for a in actors:\n", " G.add_node(a)\n", "for src, dst, label in messages:\n", " G.add_edge(src, dst, label=label)\n", "\n", "plt.figure(figsize=(12, 6))\n", "pos = {\"Executive\": (0, 0), \"Briefing App\": (1, 0), \"Copilot Notebook\": (2, 0), \"Approved M365 Data\": (3, 0)}\n", "nx.draw_networkx_nodes(G, pos, node_size=3500, node_color=\"#E8F5E9\")\n", "nx.draw_networkx_labels(G, pos, font_size=10)\n", "nx.draw_networkx_edges(G, pos, arrows=True, arrowstyle=\"-|>\", arrowsize=18, connectionstyle=\"arc3,rad=0.15\")\n", "edge_labels = {(u, v): d[\"label\"] for u, v, d in G.edges(data=True)}\n", "nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)\n", "plt.title(\"Sequence of a Governed Executive Briefing Request\")\n", "plt.axis(\"off\")\n", "plt.show()" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: simulate pilot license validation data in Python\n", "\n", "The source material included PowerShell for checking pilot user readiness. Because this notebook is Python-first, the next cell creates an equivalent validation table showing how you might flag whether pilot users appear to have candidate license assignments." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import pandas as pd\n", "\n", "pilot_users = [\n", " {\"User\": \"alex@contoso.com\", \"AssignedSkus\": [\"ENTERPRISEPACK\", \"COPILOT_M365\"]},\n", " {\"User\": \"sam@contoso.com\", \"AssignedSkus\": [\"SPE_E5\"]},\n", " {\"User\": \"jamie@contoso.com\", \"AssignedSkus\": [\"BUSINESS_BASIC\"]},\n", "]\n", "\n", "rows = []\n", "for user in pilot_users:\n", " sku_text = \", \".join(user[\"AssignedSkus\"])\n", " has_candidate = any(token in sku_text for token in [\"COPILOT\", \"ENTERPRISEPACK\", \"SPE\"])\n", " rows.append({\n", " \"User\": user[\"User\"],\n", " \"AssignedSkus\": sku_text,\n", " \"HasCopilotCandidateLicense\": has_candidate,\n", " })\n", "\n", "license_df = pd.DataFrame(rows)\n", "license_df" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: simulate tenant readiness signals for a Copilot pilot\n", "\n", "The blog emphasizes that adoption depends on policy envelope readiness, not just feature availability. This cell creates a simple readiness object you can adapt into a real assessment framework." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import pandas as pd\n", "\n", "readiness = {\n", " \"TenantDisplayName\": \"Contoso Ltd.\",\n", " \"TenantId\": \"00000000-0000-0000-0000-000000000000\",\n", " \"Country\": \"US\",\n", " \"UsageLocationSet\": True,\n", " \"VerifiedDomains\": \"contoso.com, contoso.onmicrosoft.com\",\n", " \"SecurityDefaultsEnabled\": \"Review in Entra admin center\",\n", " \"SharePointGovernanceReviewed\": \"Review site permissions and external sharing\",\n", "}\n", "\n", "readiness_df = pd.DataFrame([readiness]).T\n", "readiness_df.columns = [\"Value\"]\n", "readiness_df" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Example: produce a governance checklist report for an executive Copilot pilot\n", "\n", "The blog recommends starting with a governance checklist before executive enthusiasm. This cell creates a checklist, exports it to CSV, and displays the result so teams can validate ownership and control coverage." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import pandas as pd\n", "from pathlib import Path\n", "\n", "checklist = [\n", " {\"Control\": \"Pilot users licensed\", \"Status\": \"Check\", \"Owner\": \"M365 Admin\"},\n", " {\"Control\": \"Sensitivity labels reviewed\", \"Status\": \"Check\", \"Owner\": \"Compliance\"},\n", " {\"Control\": \"SharePoint permissions cleaned up\", \"Status\": \"Check\", \"Owner\": \"Collaboration Admin\"},\n", " {\"Control\": \"Meeting recording policy validated\", \"Status\": \"Check\", \"Owner\": \"Teams Admin\"},\n", " {\"Control\": \"Executive data access exceptions documented\", \"Status\": \"Check\", \"Owner\": \"Security\"},\n", "]\n", "\n", "checklist_df = pd.DataFrame(checklist).sort_values([\"Owner\", \"Control\"])\n", "outfile = Path(\"copilot-pilot-governance-checklist.csv\")\n", "checklist_df.to_csv(outfile, index=False)\n", "\n", "print(outfile.read_text())\n", "checklist_df" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pilot flow: readiness review to executive outcomes\n", "\n", "The blog proposes a practical two-quarter playbook: establish the policy envelope first, then pilot synthesis and test trust. This cell visualizes that staged rollout path." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import matplotlib.pyplot as plt\n", "import networkx as nx\n", "\n", "steps = [\n", " \"Admin readiness review\",\n", " \"Licensing and pilot cohort\",\n", " \"Permissions and content hygiene\",\n", " \"Compliance and sensitivity labels\",\n", " \"Meeting and capture policies\",\n", " \"Notebook + multimodal pilot\",\n", " \"Executive briefing outcomes and feedback\",\n", "]\n", "\n", "G = nx.DiGraph()\n", "for i in range(len(steps) - 1):\n", " G.add_edge(steps[i], steps[i + 1])\n", "\n", "plt.figure(figsize=(14, 7))\n", "pos = {step: (i, 0) for i, step in enumerate(steps)}\n", "nx.draw_networkx_nodes(G, pos, node_size=3200, node_color=\"#FFF3CD\")\n", "nx.draw_networkx_edges(G, pos, arrows=True, arrowstyle=\"-|>\", arrowsize=18)\n", "nx.draw_networkx_labels(G, pos, font_size=9)\n", "plt.title(\"Two-Quarter Pilot Flow for Governed Executive Synthesis\")\n", "plt.axis(\"off\")\n", "plt.show()" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Validate the policy envelope with a simple scoring model\n", "\n", "A core question from the blog is what breaks first if Copilot starts assembling more executive context: permissions hygiene, retention policy, or executive trust. This cell creates a simple scoring model to help teams quantify readiness and identify the weakest control area." ] }, { "cell_type": "code", "metadata": {}, "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "scores = {\n", " \"Permissions hygiene\": 2,\n", " \"Retention policy\": 3,\n", " \"Sensitivity labeling\": 3,\n", " \"Provenance and citations\": 4,\n", " \"Approval boundaries\": 2,\n", " \"Executive trust\": 2,\n", "}\n", "\n", "score_df = pd.DataFrame(list(scores.items()), columns=[\"ControlArea\", \"Score\"])\n", "score_df = score_df.sort_values(\"Score\")\n", "print(score_df)\n", "\n", "plt.figure(figsize=(10, 5))\n", "plt.barh(score_df[\"ControlArea\"], score_df[\"Score\"], color=\"#6C8EBF\")\n", "plt.xlim(0, 5)\n", "plt.xlabel(\"Readiness Score (1-5)\")\n", "plt.title(\"Policy Envelope Readiness Assessment\")\n", "plt.show()\n", "\n", "weakest = score_df.iloc[0]\n", "print(f\"Weakest area: {weakest['ControlArea']} (score={weakest['Score']})\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Simulate citation-backed executive outputs versus unsupported summaries\n", "\n", "The blog makes a strong distinction between decorative synthesis and decision support. This cell compares a citation-backed briefing item with an unsupported one so teams can validate what trustworthy output should look like." ] }, { "cell_type": "code", "metadata": {}, "source": [ "supported_output = {\n", " \"claim\": \"Revenue risk in EMEA due to delayed renewals.\",\n", " \"citations\": [\n", " {\"title\": \"Q2 Renewal Review\", \"location\": \"SharePoint / Sales Reviews\"},\n", " {\"title\": \"EMEA Escalation Thread\", \"location\": \"Outlook\"},\n", " ],\n", " \"classification\": \"Advisory\",\n", "}\n", "\n", "unsupported_output = {\n", " \"claim\": \"Everything is on track in EMEA.\",\n", " \"citations\": [],\n", " \"classification\": \"Unknown\",\n", "}\n", "\n", "for label, item in [(\"SUPPORTED\", supported_output), (\"UNSUPPORTED\", unsupported_output)]:\n", " print(f\"\\n{label}\")\n", " print(\"Claim:\", item[\"claim\"])\n", " print(\"Classification:\", item[\"classification\"])\n", " if item[\"citations\"]:\n", " print(\"Citations:\")\n", " for c in item[\"citations\"]:\n", " print(f\"- {c['title']} | {c['location']}\")\n", " else:\n", " print(\"- No citations available\")" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Test approval boundaries for sensitive actions\n", "\n", "Another major theme is that advisory synthesis and transactional execution should be separated. This cell applies a simple policy function to determine whether downstream actions should be auto-allowed or routed for approval." ] }, { "cell_type": "code", "metadata": {}, "source": [ "actions = [\n", " {\"task\": \"Draft internal follow-up email\", \"sensitivity\": \"Confidential\", \"externalSharing\": False},\n", " {\"task\": \"Share briefing with external counsel\", \"sensitivity\": \"Highly Confidential\", \"externalSharing\": True},\n", " {\"task\": \"Create CRM follow-up task\", \"sensitivity\": \"Confidential\", \"externalSharing\": False},\n", "]\n", "\n", "def evaluate_action_policy(action: Dict[str, Any]) -> str:\n", " if action.get(\"externalSharing\"):\n", " return \"Approval Required\"\n", " if action.get(\"sensitivity\") in {\"Highly Confidential\", \"Restricted\"}:\n", " return \"Approval Required\"\n", " return \"Advisory/Allowed\"\n", "\n", "policy_results = []\n", "for action in actions:\n", " result = dict(action)\n", " result[\"policyDecision\"] = evaluate_action_policy(action)\n", " policy_results.append(result)\n", "\n", "pd.DataFrame(policy_results)" ], "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Summary\n", "\n", "This notebook validated the blog's main idea through runnable examples: executive knowledge work benefits when retrieval is scoped, synthesis is grounded, outputs include citations, and actions respect governance boundaries. The practical takeaway is that notebook-style experiences become strategically important only when they sit inside a trusted architecture of identity, permissions, retention, labeling, provenance, and approval controls.\n", "\n", "## Next Steps\n", "\n", "1. Pick one narrow executive workflow such as a weekly briefing or risk review.\n", "2. Inventory the approved context sources and define explicit scope boundaries.\n", "3. Score your policy envelope across permissions, retention, labeling, provenance, and trust.\n", "4. Pilot citation-backed synthesis with a small leadership cohort.\n", "5. Keep sensitive actions behind explicit approval until controls are proven." ] } ] }