AI for CPM Scheduling and Primavera P6: What Works Today

AI can already do real work on CPM schedules: drafting a first-pass schedule from drawings, specs and meeting notes, reading XER exports to flag logic and quality problems, and answering questions against Primavera P6 through a governed tool layer. What it cannot do is replace the scheduler's judgment. The approaches that work keep a human in charge of assumptions, sign-off and anything written back to P6, and they attach evidence to every activity the AI touches.

This guide covers what is practical today, where the risks are, and how to run a pilot without putting a live schedule at risk. It is grounded in two systems we built: Connect, an agentic scheduling platform, and a Model Context Protocol (MCP) server for Primavera P6.

What "AI for CPM scheduling" actually means

The phrase covers several very different jobs. Mixing them up is the most common reason pilots disappoint.

• Schedule drafting. Turning project documents into a first-pass logic network: activities, durations, relationships, WBS. This is generation, and it needs the most oversight.
• Schedule analysis. Reading an existing schedule and reporting on it: critical path, float, open ends, constraints, relationship types, resource loading, earned value. This is mostly deterministic calculation, with AI used to explain and prioritize findings.
• Schedule interaction. Asking questions of a live scheduling system in plain language ("which activities on the driving path slipped since last update?") and, with approval, making changes.
• Schedule communication. Drafting weekly or monthly client updates from schedule changes, meeting notes and site records.

A few definitions used throughout:

• CPM (critical path method): a scheduling technique that models activities and their logic ties to compute early and late dates, float and the longest path through the project.
• XER: Primavera P6's native export format. One delimited text file holds many tables (projects, WBS, activities, relationships, calendars, resources).
• MCP: the Model Context Protocol, an open standard that lets AI clients such as Claude Desktop or Cursor call external tools in a consistent way.
• Schedule health check: a set of rule-based tests on logic quality, such as missing predecessors or successors, excessive lags, hard constraints and high float. The DCMA 14-point assessment is a widely used reference set.

What works today, and what still needs a person

The pattern is consistent: the further a task moves from reading to writing, the tighter the human control needs to be.

AI-drafted schedules: why evidence matters more than speed

A schedule an AI produces in minutes is only useful if the scheduler can check it faster than they could have built it. That means every activity needs to show where it came from.

In Connect, we split schedule creation into the same steps a scheduler follows, with one agent per step:

1. Info Sheet agent (the "what"). Reviews the project files, drawings and transcribed client meetings and produces a normalized project information sheet. Files are stored in a predefined folder structure, read with OCR and indexed, so the agent can point to the file each piece of information came from. The goal is to cut the time spent reading hundreds of pages of specifications and drawings by hand.
2. Means & Methods agent (the "how"). Generates the questions that cannot be answered from the documents, such as sequence, logistics and owner requirements. The scheduler answers them or sends them to the client through email or a password-protected link. Answers are marked client-verified, every change has an audit trail, and the AI can suggest a redraft but will not guess an answer.
3. Schedule Builder agent. Combines the info sheet, means and methods and source files into a CPM schedule. It supports different schedule types (baseline, RFI/RFP, new build), runs largely on its own for roughly 10 to 15 minutes, asks the user when it needs clarification, scores the schedule's health, keeps activity evidence showing how it arrived at each decision, keeps a version history of its drafts and exports an XER file.

The scheduler then imports that XER into a full scheduling viewer to filter, group, check driving and critical paths and validate before anything goes to the client. Revised schedules can be imported back, and the scheduler can chat with the schedule to make further changes.

The point is not that the AI writes the schedule. It is that the work of collecting the "what" and the "how" becomes structured, reviewable and repeatable, and the draft arrives with its reasoning attached. Our Connect article and full platform walkthrough cover each step in detail.

XER analysis without a live P6 connection

Most schedule analysis does not need live database access. An XER export contains everything required to check logic quality, trace the critical path and review resources, and working from a file removes most of the security questions a pilot raises.

The P6 MCP server we built includes 13 offline XER tools. Together they parse the file and report on:

• Activities and activity detail
• Critical path
• Schedule quality
• Resources and resource utilization
• WBS structure
• Relationships between activities
• Calendars
• Schedule summary
• Earned value

Because these run against an exported file, an agent in Claude Desktop or Cursor can answer "what is driving the finish date?" or "list activities with no successor" without credentials to the P6 database. That makes offline XER analysis the safest first step for most teams.

If you only need schedule data in reports, an XER can also be loaded straight into Power BI. In a Procore and P6 proof of concept, we loaded an XER file through Power Query and reported it alongside Procore RFIs synced to Azure Cosmos DB, so one report showed RFI schedule impact next to the P6 tasks. That build is written up in Procore + P6 analytics with Azure and Power BI.

Schedule health checks: let rules find it, let AI explain it

Health checks are where AI adds value with very little risk, as long as the division of labor is right.

• Rules do the detection. Missing logic, open ends, negative or excessive float, hard constraints, long lags and out-of-sequence progress are all computable. A deterministic test gives the same answer every time, which is what you want on a schedule submitted to an owner.
• AI does the triage and explanation. Which failures matter on this project? Which ones are deliberate (a contractual milestone constraint) and which are mistakes? A model with access to the schedule and the project documents can draft that narrative quickly.
• The scheduler decides. Some "failures" are correct for the job. The person accountable for the schedule makes the call.

In Connect, the Schedule Builder runs its validation tests on every draft and produces a health score. When a test fails, the user can ask the builder to fix it and give it additional context. Each export is kept in the version history, so earlier drafts stay available for comparison.

Working with Primavera P6 through MCP

Live P6 access is where AI scheduling gets genuinely useful, and where it needs the most care. P6's REST API is large. The P6 MCP server we built covers 585 operations across 101 P6 entities.

Handing an agent 585 tools does not work. It cannot choose reliably, and the tool list crowds out the context it needs to reason. Our design gives the agent a small surface instead:

• Generated catalog. The capability catalog and a typed REST client are generated from the official P6 OpenAPI spec and the P6 help and API documentation, not hand-written.
• Discovery and ranking. The agent describes what it wants, and the gateway searches the catalog to surface only the relevant operations, their dependencies and required fields.
• Workflow playbooks. YAML playbooks define the correct sequence of operations for common jobs, with checkpoints along the way.
• Governance on every call. Requests pass through policy, rate limits, caching and audit logging. Mutations can be previewed, and policy-gated actions go to a named user for approval.
• Per-organization credentials. Credentials are provisioned and partitioned per organization, so no two organizations share authorization tokens.

A first session follows a predictable path: get session context, discover operations, list projects. From there the agent orients and reads before it acts; changes can be previewed, and policy-gated changes wait for a named user's approval. The P6 MCP server article and video walkthrough go deeper, and What is MCP for construction explains the protocol itself.

Where humans must stay in the loop

Regardless of tooling, keep a person accountable at these points:

1. Assumptions. Any duration, sequence or resource assumption the AI could not trace to a document or a client answer.
2. Baselines. Nothing becomes a baseline without a scheduler's review and sign-off.
3. Write-backs to P6. Every mutation is previewed and approved. Start with no write access at all.
4. Anything sent to the owner. Client updates, narratives and delay analysis are drafts until a person publishes them.
5. Agent changes. Prompt, model or tool changes to the agents themselves go through review. In Connect, an executive admin portal grades agents against rubrics and golden reference sets, and proposed improvements sit in a review queue until an admin approves them.

This mirrors the principles we design to: evidence on every output, flag rather than drop, and least privilege by default. The Approach and Governance pages explain them, and our guide to governing AI agents in construction covers the controls in more depth.

How to pilot AI scheduling safely

A pilot should prove value on real schedules without touching production. This sequence works:

1. Pick one question worth answering. For example, "cut the time to review an incoming subcontractor schedule" or "flag logic problems before monthly updates go out." A narrow goal makes success measurable.
2. Start with exported XER files. Use completed or current projects exported to XER. No live credentials, no write risk.
3. Write down your health rules. Agree which checks matter and what thresholds you use before the AI runs. Otherwise you are grading the AI against a moving target.
4. Compare against a scheduler's review. Have the AI and an experienced scheduler review the same schedule. Track what each found, what the AI missed and what it flagged incorrectly.
5. Require evidence on every finding. If the AI cannot point to the activity, relationship or document behind a statement, treat the statement as unverified.
6. Add read-only live access next. Connect to a non-production P6 database or a restricted account with read-only permissions. Log every call.
7. Try drafting on a closed project. Have the AI draft a schedule from the documents of a project you have already scheduled, then compare it to what your team built. You learn its blind spots without any client exposure.
8. Introduce writes last, with approval. Only after the read paths are trusted, and only with preview and named approval on each change.
9. Decide with your schedulers. The people who own the schedules should decide whether the tool goes further.

Common mistakes

• Asking a general chatbot to "build a schedule from these PDFs." It skips the step where a professional separates what is known from what is assumed. Break the work into steps and review each one.
• Accepting a schedule because it looks complete. A clean Gantt chart is not a sound logic network. Run health checks on every draft, AI-built or not.
• Exposing every API endpoint as a tool. Large tool lists make agents less reliable. Use discovery, ranking and playbooks.
• Giving the AI write access on day one. Read-only and offline XER analysis deliver most early value with almost none of the risk.
• No audit trail. If you cannot reconstruct what the agent read, called and changed, you cannot defend the schedule later.
• Letting the model guess client answers. Unknowns should become questions, not assumptions.
• Measuring speed only. Measure review time saved and issues caught. A fast draft that takes longer to check is a net loss.

How we approach it

Our scheduling work comes from building these systems end to end, not from wrapping a chatbot around P6.

• Connect turns the scheduler's procedure into specialized agents, from the info sheet and means and methods through schedule building, job walks with photos and transcribed audio, and automated client updates. Every output is versioned with its evidence, and the platform can be driven from Claude, Codex or any MCP client through the Connect MCP.
• P6 MCP makes Primavera P6 usable by AI agents through a generated catalog, a governed gateway and offline XER tools.
• Schedule data in reporting. We bring critical-path activities and milestones into Power BI and Microsoft Fabric reporting alongside cost and project management data, as in our construction project reporting showcase.

We start with a specific scheduling problem, prove it on exported data, add live access with governance, and hand over something your team owns and can audit. The scheduling topic page and our page for scheduling teams collect the related work.

Where to go next

• Watch the Connect agentic scheduling walkthrough to see a schedule drafted, health-checked and exported to XER.
• Read Building an MCP server for Primavera P6 for the architecture behind governed P6 access and offline XER analysis.
• Explore the Connect platform article for each agent in the scheduling procedure.
• Have a scheduling process you want to standardize or a P6 question you want answered faster? Tell us what you want to build.