Every project manager we've ever worked with has the same relationship with their meeting notes: proud of them, and quietly resentful of what comes next.
You run a solid meeting. You take thorough notes in OneNote — action items, owners, due dates, decisions made, and risks flagged. The meeting ends. And then you open Microsoft Planner and spend the next half hour manually re-creating everything you just wrote down.
That gap — between the notes and the task board — is one of the most universal and least glamorous problems in project management. We decided to close it.
Where Project Managers Lose Time
Before we built anything, we wanted to understand exactly where the time was going. We talked to project managers running large portfolios on Microsoft 365 and mapped the post-meeting workflow step by step:
- Read through the OneNote page to identify action items
- Open Planner, create a new task for each item
- Type or paste the task title and description
- Search Entra ID (or the org directory) for each owner's name
- Assign the task to the correct user account
- Set the due date in the correct format
- Paste a link back to the source notes in the task description
- Go back to OneNote, update the page to show it's been processed
For a single meeting with five action items, that's 20 to 35 minutes. For a Project Manager running five recurring meetings a week, that's up to three hours of structured copy-paste — every single week. Across a team of ten Project Managers, the math becomes uncomfortable fast.
And that's assuming nothing goes wrong. In practice, owners get misassigned because two people share the same first name. Due dates get dropped when the Project Manager is moving quickly. Decisions and risks — which matter for governance and project retrospectives — never make it into the task system at all because Planner doesn't have a native place for them.
The status quo was: thorough documentation in one place, incomplete execution in another, and no audit trail connecting the two.
The Design: AI Extracts, Humans Approve, Automation Creates
We had a clear constraint from the start: this tool had to work the way Project Managers already work, not ask them to change their behavior. No new interfaces, no special templates, no training sessions.
The trigger we landed on was a single status tag in OneNote. When a Project Manager finishes their meeting notes and is ready for tasks to be created, they add one line:
STATUS: READY
That's it. Everything else is automatic.
Here's what happens next:
The system detects the tag and retrieves the page. A polling loop runs continuously, checking for OneNote pages with STATUS: READY. When it finds one, it fetches the full page content via the Microsoft Graph API.
An AI model reads the notes and extracts structure. The page content is passed to a large language model with a prompt designed to identify and classify all relevant items: ACTION tasks (with the owner's name and due date), DECISION records, and RISK flags. The model returns structured JSON — not a summary, not a rewrite, but machine-readable data ready for the next step.
This is where the design became significantly more complex. Meeting notes are written in natural language by humans under time pressure. They don't follow a rigid schema. The AI needs to recognize “John should follow up on the vendor contract by the end of next week” as an action item owned by John, due in seven days — not just lines that literally start with “ACTION:”. Getting this right took careful, prompt engineering and testing against real notes from real meetings.
Owner names are resolved against Entra ID. The extracted owner names — “Sara,” “Raj,” “the infrastructure team” — are looked up against the organization's Azure Entra ID directory in real time. When a name matches a known user, their account ID is linked automatically. When a name is ambiguous or unknown, it's flagged rather than silently mis-assigned.
A Teams card requests approval. Before any task is created, the Project Manager receives a structured summary in Microsoft Teams — a native adaptive card that shows every extracted task, its owner, and its due date, along with any identified decisions and risks. Two buttons: Approve or Reject.
This step is non-negotiable in our design philosophy. AI systems make mistakes. A Project Manager who has just run the meeting is the right person to review the extraction before it becomes someone else's work. The approval step takes about 30 seconds and catches errors before they propagate.
On approval, Planner tasks are created automatically. Each task is assigned to the resolved user account, given the correct due date, and linked back to the source OneNote page in its description. Tasks appear on the team's Planner board within seconds of the PM clicking Approve.
The OneNote page is marked processed. The status tag is updated to STATUS: PROCESSED. The page will never be re-processed, and anyone looking at the notes later can see at a glance that tasks have been created from them.
Every step is logged. A JSON audit file captures the full record: what was extracted, what the owner resolution found, what the Project Manager approved, and what was created in Planner — all with timestamps. For client-facing projects or regulated environments, this is documentation that the manual process never produced.
What Building the System Taught Us
A few things surprised us during development.
Natural language is messier than it looks. We initially expected that meeting notes written by experienced Project Managers would have a reasonably consistent structure. They don't — and that's fine, because humans aren't writing for machines. The AI extraction had to handle abbreviated names, implicit due dates (“before the next sprint”), passive constructions (“it was agreed that…”), and action items buried mid-paragraph. The prompt went through many iterations before it was reliable across diverse note styles.
Owner resolution is the hardest part of the pipeline. Matching “Sara” to a specific user account within an organization with multiple users named “Sara” is genuinely ambiguous. We settled on a confidence-based approach: high-confidence matches are resolved automatically, low-confidence matches are surfaced to the Project Manager in the approval card. Unresolved owners don't block task creation — the task is created with an unassigned owner and a clear note — because a task with no owner is still better than a task that was never created.
The human approval gate made the tool trustworthy. Early in testing, we considered making the pipeline fully automatic — extract and create without any review step. Users pushed back immediately. The approval card isn't just a safety net; it's what made PMs comfortable with the tool. Knowing that nothing hits Planner without their sign-off meant they trusted the output. That trust was essential for adoption.
The audit log turned out to be more valuable than expected. We included it primarily for compliance use cases. In practice, Project Managers started using it to review extraction quality over time and to reconstruct the history of decisions made in meetings — something that was previously only possible by reading through raw notes.
Inside The Technical Stack
The integration is built in Python and runs as a long-lived background process inside the client's Microsoft 365 tenant. It uses:
- Microsoft Graph API for OneNote page retrieval, Entra ID user lookup, and Planner task creation
- MSAL (Microsoft Authentication Library) for delegated user authentication (OneNote access) and app-only credentials (Planner and Entra ID)
- An OpenAI-compatible LLM endpoint for task extraction — we run our own small, edge model in-house for this, but it can be Azure OpenAI, OpenAI directly, or any compatible API, depending on the client's data sovereignty requirements
- Microsoft Teams incoming webhooks for the approval card
- A lightweight HTTP server running on a background thread to receive the approval/rejection callback from Teams
The two-thread architecture — poller loop plus callback server — lets the system process approvals in real time without polling. When the Project Manager clicks Approve in Teams, the callback fires immediately, and Planner tasks are created within seconds.
Deployment is straightforward: Docker container or systemd service, with a reverse proxy handling TLS termination for the Teams callback endpoint. All credentials stay in the client's environment. No data is sent to Intelegencia.
The Results After Deployment
For the pilot team — ten project managers running an average of five recurring meetings per week each — the numbers were clear:
- Manual task entry time: Eliminated
The 20 to 35 minutes per meeting cycle dropped to the 30 seconds it takes to review and click Approve.
- Action item capture rate: 100%
In the pre-automation baseline, the team estimated that roughly 15% of action items from meetings never made it into Planner. That number went to zero.
- Time to task creation: Minutes, not days
Under the manual model, tasks sometimes appeared in Planner a day or two after the meeting. With automation, they're there before the team's next standup.
The organization now has a full record of every action item extracted, every approval decision, and every task created — something that simply didn't exist before.
What's Next
The core pipeline is stable and deployed. We're currently exploring a few directions for the next phase:
- Multi-notebook support: The current deployment monitors a single notebook. We're extending the poller to handle multiple notebooks across a tenant, enabling us to cover entire project portfolios from a single deployment.
- Slack integration: The approval card mechanism is built around Teams, but the design is modular. A Slack-based approval flow using Block Kit is a natural next step for organizations that run their communications in Slack.
- Richer extraction outputs: Right now, the system extracts tasks, decisions, and risks. We're experimenting with extracting meeting attendees, referenced documents, and follow-up meeting commitments — surfacing more of the structure that's already in the notes but currently invisible to the task system.
- Private LLM endpoints: For organizations with strict data residency requirements, we're formalizing support for privately hosted LLM endpoints, including fine-tuned models trained on the organization's own meeting note history for higher extraction accuracy.
Run the Workflow in Your Microsoft 365 Environment
If your team runs on Microsoft 365 and you're still bridging the OneNote-to-Planner gap manually, we'd love to show you what this looks like on your actual notebooks.
We offer a structured 2 to 3-week pilot: we configure and deploy against your highest-volume notebooks, you see real tasks in Planner from real meetings, and at the end, you have real data to decide whether to roll it out further. At Intelegencia, we incorporate cutting-edge AI technologies to deliver optimal results and save our clients both time and money.