How Specialized AI Agents Standardize CPM Scheduling

Every scheduler has a process. The trouble is that it usually lives in one person's head. Two schedulers given the same drawings, specs and client meetings can produce two different CPM schedules, and neither one can easily show why a given activity, duration or sequence is there. Months later, when the client asks why the schedule looks the way it does, the answer is spread across email threads, meeting notes and memory.

Connect is the agentic AI platform we built for Syncify to fix that. It sits on top of Syncify, a scheduling solution and CPM engine for construction projects, and it turns the scheduler's standard procedure into a sequence of specialized AI agents. Each agent owns one step, outputs keep the evidence behind them, and drafts are versioned. This article explains how it works, why we designed it this way, and what you can take from it even if you never use Connect.

The problem: CPM scheduling runs on unwritten procedure

A good CPM schedule needs two kinds of knowledge:

• What is being built. Scope, systems, quantities, constraints. Most of this is buried in hundreds of pages of drawings and specifications, plus whatever was said in client meetings.
• How it will be built. Sequence, means and methods, site logistics, owner requirements. Much of this cannot be read from the documents at all. Someone has to ask the client.

In most firms, both kinds of knowledge are collected informally. A scheduler reads the drawings, jots notes, emails a few questions, waits for answers and builds the schedule in Primavera P6 or a similar tool. The result can be excellent, but the process is hard to repeat, hard to review and hard to hand off. When the schedule is wrong, it is hard to tell whether the problem was a missed spec, a wrong assumption or an unanswered question.

Throwing a general-purpose chatbot at this does not help much. A single prompt that says "build me a schedule from these PDFs" skips the step where a professional decides what is known, what is assumed and what still has to be confirmed. That step is the whole job.

The approach: one agent per step of the scheduler's procedure

Connect breaks the scheduler's workflow into steps and gives each step to a dedicated agent. A general agentic chat sits on top and can call every agent as a tool, so a user can ask a question, upload files, transcribe a meeting or kick off a build from one place.

The order matters. The info sheet is the "what." Means and methods is the "how." Only when you have both does it make sense to generate a schedule.

How it works, step by step

1. Organize work into programs and projects

Everything lives under a project, which maps to a real job and controls who can see it. Projects are grouped into programs, which can be organized by client, project type or anything else a team needs. In the demo we walk through a project called 140 Fulton.

2. Turn files and meetings into retrievable evidence

Each project has a predefined folder structure. Uploaded files are processed with OCR and stored as vector embeddings, so agents can retrieve the exact file and passage they rely on. The agents still pull the source files; the embeddings make it faster to find and cite the right context.

Schedulers also spend a lot of time in client meetings. Connect records and transcribes those conversations, summarizes them and lets users tag them, so what was said in a meeting becomes searchable context for every agent. Nothing depends on someone remembering to write it down.

3. Build the info sheet: the project's source of truth

The Info Sheet agent reviews everything assigned to the project (drawings, documents and transcripts) and organizes it into sections based on what it finds. It extracts the specifics of what is being built and normalizes them into a single document the scheduler can save and reference.

A run takes roughly 10 to 15 minutes. It replaces manual review of hundreds of pages of specs and drawings with a consistent, reviewable output that every later step uses.

4. Generate the means and methods questions

Some answers cannot be extracted from documents. The Means & Methods agent reviews the info sheet and project documentation and produces a list of the questions that still need answering, the things a scheduler should not assume.

Each question can be answered by the scheduler or sent to the client. To send it to the client, the scheduler either emails the request or creates a secure, password-protected link. The client answers directly (in the demo, "no dewatering required"), submits, and the answer shows up in Connect marked as client verified.

Two details make this trustworthy:

• Version history and audit trail. Every change to the means and methods is recorded.
• AI redraft that does not guess. The agent can suggest an answer based on context, but it is designed not to guess. The recommendation is a draft for a person to accept or change.

The finished means and methods can be printed or saved as a project document.

5. Build the CPM schedule

The Schedule Builder agent combines the info sheet, the means and methods and the project files. It runs the calculations and analysis, asks the user questions when it needs to, and applies validation tests and standard operating procedures for specific project types. It supports different schedule types, including baseline, RFI/RFP and new construction schedules.

A build takes roughly 10 to 15 minutes and runs largely on its own. When it finishes you get:

• A health score from a set of validation tests. If a test fails, you can ask the builder to fix it and give it more context.
• Activity evidence showing how the agent arrived at each part of the schedule.
• A full version history of every draft.
• A standard XER export that you can import back into Connect later and revise by prompting.

6. Review it in a real schedule viewer

We deliberately did not rebuild a Gantt chart. Schedules are imported into Syncify, where the scheduler can filter, group, sort and inspect critical and driving paths before anything goes to the client. If the scheduler revises the schedule there, the revised version can be brought back into Connect. Users can also set a "basis of schedule" (the standards they want followed) and choose which info sheet and means and methods a schedule should draw on.

7. Capture the job walk

On site, the job walk feature gives the user a checklist they can edit, plus photo, video and audio capture. Audio is transcribed automatically. When the walk ends, everything is tied back to the project, so the agents can use it as auditable context.

8. Draft client updates

Once the project is won and underway, the Updates agent drafts weekly or monthly updates. It pulls what changed over a set period: schedule changes from Syncify, means and methods, info sheets and uploaded documents. It adds recommendations such as adjustments to consider or risks to watch. It asks clarifying questions, and you can question it about the draft. The published update gets a share link, where the client can read it, ask questions and confirm requests. History and export are kept for both sides.

Beyond the UI: connectors, apps and the Connect MCP

Three features extend Connect beyond its own screens:

• Connectors bring in external and third-party data. Syncify is the main one, since schedules live there. That data enriches schedule generation, updates and apps.
• The AI App Builder generates front-end deliverables in HTML, CSS and JavaScript from project and schedule data, for clients who want something visual. Apps are assigned to projects, shared by link, versioned and downloadable as source.
• The Connect MCP exposes the platform's capabilities as tools through the Model Context Protocol. From Claude, Claude Code, Codex or any MCP-capable agent, a user can get files, generate an info sheet, search project information, answer means and methods questions and generate schedules using the same procedure the platform uses. If MCP is new to you, start with what MCP means for construction.

An agentic alert system rounds this out: rule-based alerts, prebuilt or created by an agent, are checked each time a schedule is updated or uploaded.

Governing the agents: the executive admin portal

Agents only earn trust if someone can see and steer them. The executive admin portal is where that happens.

• Agent health and configuration. For each agent: the system prompt, the model, the tools it can call, version control and knowledge sources. Admins can add skills or knowledge from data sources the workspace can access.
• Full logs. Every agent run records its turns, tool calls, inputs and outputs. The logs are also available through the MCP, so an agent like Claude Code can review them for errors or improvement opportunities.
• Quality rubrics and golden sets. Agents are graded against rubrics and against reference sets of preferred answers, so a drop in quality shows up and can be prioritized.
• Self-improvement with a review queue. An agent can propose improvements (knowledge documents, prompt changes, model changes, new grading rules). Proposed changes go to a review queue for an admin to approve. Autopilot can be turned on, but it is a choice.
• Usage analytics. Which agents, tools, models and users are active, plus token costs and success rates.
• Workspaces, roles and feature flags. Organizations get workspaces with admin, member and guest roles. Features such as specific agents, audio transcription and MCP access, including whether external tools can use the Schedule Builder, can be turned on or off per workspace. Each workspace has its own vector knowledge base, which can be re-indexed, and app-builder data queries are tracked for approval.

Connect can also be embedded as an iFrame inside another product.

For a broader treatment of this governance layer, see our guide to governing AI agents in construction.

Design decisions and why we made them

• Narrow agents instead of one big prompt. Each agent has one job and a clear input and output. That makes each step testable, gradable and replaceable without reworking the whole system.
• "What" before "how" before schedule. The order mirrors how good schedulers already work. It also forces the system to say what it does not know before it builds anything.
• The client answers their own questions. A secure link and a "client verified" status are worth more than a confident guess from a model.
• Evidence on every output. Activity evidence, citations to files and passages, and version history mean a schedule can be defended, not just produced.
• Standard formats out. XER export means the schedule works in the tools the industry already uses. AI drafts the schedule. The scheduler reviews and signs off.
• Reuse a real viewer. Syncify already does Gantt views, critical paths and driving paths well. Rebuilding that would have added risk without adding value.

These map to principles we apply on every build. See our approach.

Practical lessons if you are bringing AI into scheduling

1. Write down your procedure first. If your team cannot list the steps from intake to baseline, an AI tool will not invent a good one. Connect started from a written procedure, not from a model.
2. Separate facts from assumptions. Keep a source-of-truth document for what the drawings say and a separate, tracked list of open questions. That alone improves schedules, with or without AI.
3. Make the client part of the record. Answers that come straight from the client, with a timestamp and audit trail, end a lot of arguments.
4. Insist on evidence and versions. Any AI-generated activity should show where it came from, and every draft should be recoverable.
5. Govern agents like software. Prompts, models and tools change. Treat them as configuration that is reviewed, graded against known-good answers and approved before release.
6. Keep standard outputs. If the result cannot leave the platform as XER, it will struggle to survive contact with the rest of your project controls stack.

For a broader look at where AI fits in CPM work, read our guide on AI for CPM scheduling and Primavera P6.

Where to go next

• Watch the full walkthrough on the Connect agentic scheduling demo page.
• See how we expose Primavera P6 to agents in the P6 MCP server article.
• Explore more scheduling work on the scheduling topic page.
• Have a scheduling procedure you want to standardize? Tell us what to build.