Connect: Agentic AI for Construction Scheduling

[00:00] All right. Today we are reviewing the Connect solution by Syncify. Syncify is a scheduling solution and CPM engine specifically for construction projects, and today we are reviewing the Connect solution for Syncify. Essentially, this is the agentic platform that outlines a lot of the standard procedures and processes that a scheduler goes through, to enhance their systems and processes, standardize those procedures and make them work more efficiently. The idea is that Connect is an agentic AI platform with a ton of functionality and capabilities. Specifically, everything is built within

[00:45] programs. These are predefined, preselected. You can create and customize however many programs you want, and that is essentially a way to consolidate all of your projects. These projects can then be associated and assigned. As a general contractor or person is working on a project, they can work on a multitude of different projects and consolidate those into a program. Of course, there's the ability to filter and sort them by the specific type of client and project and various things like that. But the idea here is, welcome to Connect. You have an agentic chat where you can ask any questions about any of your programs or your projects. Of course, this is a general chat. It has a

[01:30] ton of functionality and capability to upload your files and do audio transcription recordings. This Connect agent also has the ability to leverage all of the agents within the platform as tools. What we'll dive into here, before I show you the general overarching Connect AI, is that there is a set structure of AI agents that we'll be reviewing and discussing today. Specifically, everything is consolidated under a project. Within a project, we have our programs here that we have defined. Essentially, if we go into a program, we'll see all of the projects that are specifically associated with it. We'll see all of these here are linked to Syncify. And essentially,

[02:15] what they are going through and doing is outlining the specific procedures and processes that we will go through to create a project and associate all of the data with it. When we have a project, we can, of course, create a new project here. Then the goal is to add files to a project. I'm going to go into a specific project, and the one we will review is 140 Fulton. When we are in this project, I get a general overview of what's happening within the project and can get into the granularity as we continue through the process. As we are showing, we want to upload the files. For these files, we have a

[03:00] predefined folder structure set. This is a file management system where the user can upload all of their files and store them. All of these are then referenced by the agent. They can be associated and assigned to the vectorization of the database that we have, and stored there. Ultimately, they can be referenced and identified. Of course, the agents are able to perform OCR and analyze all of these different projects. You can move them and associate them as well. But at its core, once we have taken in all of this data, specifically project files, we can also take in more.

[03:45] Many schedulers have meetings and recordings with their clients, so they can record these audio sessions, transcribe them and have that transcription associated with the project. So when they need to take notes and tag things, all of this documentation and information is associated with the project. Access to this data is assigned based on all of the users who manage and have access to the specific project. Once the data and transcriptions are brought into the project, you can record this

[04:30] and we can save it against the project here, and tag it if necessary. This will do the audio transcription and summary for us. Then all of this information is stored for us to reference within our agents. So, as we discussed, we're storing the files, and this is where we start getting into the hyper-specific processes for the agents. The first one is the Info Sheet agent. The Info Sheet agent is a system that takes in all of the files, documentation and resources that are assigned in the file section, as well as any other information within the project, and it then leverages

[05:15] that information through an agent chat process. I'm just showing you a quick synopsis. This takes probably around 10 to 15 minutes or so to run. What it does is review all of the documentation and resources. It creates different sections based on the context of the drawings and extracts information about the project, to identify how it's being built and the specifics of this project. This is really important, because this is, in a sense, our source of truth for the project. We are pulling and extracting all of the source of truth from these drawings, documentation and meetings. And essentially we're able

[06:00] to then normalize all of this information, generate a specific file, and reference and store it. So here I can save it. Now we have documentation that outlines all of the specific data for this project, the absolutes that can be referenced and used later. The goal is to extract data and information from the sources of truth: the files and resources received from the client. Then, once we create this project info sheet, we use the info sheet to create the means and methods. The means and methods are essentially questions that the scheduler

[06:45] needs to answer, or needs to get from the client, that can't be assumed or specifically extracted from the documentation or resources. How this works is that an agent reviews the project info as well as any documentation, and then creates a list of the specific questions that need to be answered. These can be answered by the scheduler or by the client. If you need to ask the client, we can select that. Then, when we come down here, we can create a link and/or identify who the person is and

[07:30] send them an email that says, "Hey, here's one bit of information I still need to finalize this." You can send that via email. We also have a link here, so if you come up here and give the client this password, they have access to view this and answer the questions directly. They said, "No dewatering required," submitted it, and it's complete. When we go back into Connect, we'll see that it was answered and is now client verified. This is great for collecting the information that's required. Once all of these specifics are in, this is really the means and methods. They're

[08:15] the "how" this project is being developed, and we do have a historical record, so we have that audit trail and history for every single change to the means and methods. We also have redraft with AI, which is an AI selection of what it recommends as the answer based on the context. It won't guess, though, so it provides a recommendation, and then you can print and save this as a resource and document that can be stored and referenced as well. Ultimately, once the Means and Methods agent has completed and we have done all of that, we go to the Schedule Builder. The Schedule Builder can use all of the info sheets, the

[09:00] means and methods, as well as any files and documentation. It runs all of the calculations and analysis and can query the user to identify how this project is being built for the correct schedule. There are a ton of tests and validations, and specific standard operating procedures for specific types of projects that are leveraged for this, as well as different capabilities for different types of schedules. When a user is creating a schedule, it could be an RFI or RFP schedule. It could be new construction. It could be a baseline schedule. So, ultimately, there are

[09:45] different types of schedules that can be built. This takes around 10 to 15 minutes to run and process. If there are specific questions, the agent will ask, but it does run pretty autonomously. From there, it outputs an XER file that can be exported. You can always import that back in here and prompt it to make any changes and updates. When it does a review, there is a test that it runs. It produces a health score, and if there are any failures, you can ask the builder to fix them with additional context. It also has all of the activity evidence, so how it arrived at a specific conclusion when it

[10:30] generated this. It will continually run and process and keep an entire historical record of the versions as you are exporting. So we would export this and save it here. We decided to leverage Syncify in this instance as the viewer for the schedule. So we're not recreating the entire Gantt view. We go into my workspace here and a project, and I'll import this schedule here to test. We'll upload it here, and we will import and clean. While this is importing, the goal is for the user to go into Syncify, where they can

[11:15] analyze the entire schedule and identify the exact procedures for how they would schedule this. We can drop down into it, and you'll see that it does a really great job outlining everything and taking everything into consideration. Of course, there are different capabilities within Syncify to filter, group, sort and look things up. You can check driving paths and critical paths. You can do associations. All of this can be referenced and validated by the scheduler and then ultimately provided to the client. As we come back into Connect, if you did want to

[12:00] import a new file, you can select that same file and reference it again. You can honestly chat with it and interact with it to provide any updates or enhancements as you need to make changes. So, a ton of capabilities to implement this. Of course, you can import your revised schedule. If you did change anything within Syncify, you can update your revised schedule. You can also identify your basis of schedule, which would be a recommendation or set of standards that you want to follow.

[12:45] We also have a setup function. Once this is done, you would provision your specific drivers, like what type of schedule and how you want to implement it. We can also change the source we use for the means and methods as well as the project information sheet. Essentially, the idea is that users are documenting all of the resources. They are gathering all the files. They're collaborating with the client. They're doing the audio transcriptions and recordings. And they are gathering all of this information. We also have another way of gathering information, which is job walks. If a user is on a job

[13:30] site and walking around, they would come in here and see their checklist. You can edit or add anything to your checklist, and then start taking pictures, recording or capturing audio. As you capture audio, it is all being transcribed. You can capture pictures; this one is uploading, but on your phone you'd be able to take them directly. You can take any type of video, and once this is done, you associate and assign the data to the project. When you end your walk, you have the audio transcription and all your photos and videos associated with the project, and all of this is also referenced

[14:15] within the agents as context, to audit and log all of this information. Once the project continues, and you've won the project and you're collaborating with the client and continually documenting all this information, the main thing is updates. How are you giving your weekly or monthly updates? We have the auto update, which generates a draft here. You can generate an update automatically. What happens is that it pulls and extracts all of the context of what has happened within a set duration, up to this date, and any changes associated with the schedules. So we're pulling in all

[15:00] the schedules from Syncify. We're looking at all of the schedules that have been built, any means and methods, project info sheets and any uploaded documentation. Then there are some recommendations, like "Here are some things I would recommend adjusting on the schedule," or "Here are things to be aware of." The agent will also ask questions for clarification, and if you want to ask questions about the specific update, you can do that too, to provide more context. All of this is saved, and you can publish it and share it with your client. You create a link for them to see this specific update and

[15:45] reference it for their internal documentation. They can see the report here, and they can even ask questions and confirm any type of request. So it's great for customer collaboration as well as for keeping that historical documentation. You can see the history here, and you can always export it and reference it anytime. So now we have the project information that we've been developing: we use the drawings to analyze everything that's happening on the project, then we do the means and

[16:30] methods to answer the questions. We have the builder for the schedules, we verify the schedule, we collect information from job walks, and then we update the client as we progress through the job. One of the key value-adds is that we need to integrate with external or third-party data to reference information. We have a set of connectors that we can leverage, the main one being Syncify, because we are porting in all of the schedules and information linked there. But we also have other connectors to pull information in from different sources. The idea is that as we pull in this information, we

[17:15] can reference it for schedule generation and building. We can reference it for additional context in the updates we provide to the client each week or each month. And ultimately, we can use all of this information to generate apps. These apps can be built with our AI App Builder, but we can also build them locally with any AI agent chat interface, because you can leverage the MCP. With the Connect MCP, you have full capability to use every aspect of the Connect platform. So of course you can build apps, but you can also use the MCP within Claude or Codex

[18:00] or anything else to leverage any of these agents. If you need to build an info sheet, you would have that standard procedure within Claude to run that specific process and reference data and information in the projects. You can also upload files through there. You can answer questions for means and methods and even generate schedules based on the specific procedure and process we have developed. Many clients we work with are very visual, and we want to share many types of assets and resources that convey the progression and/or the deliverables for the project. We do this through our various types of

[18:45] apps. These are essentially front-end HTML, CSS and JavaScript that extract and pull in information for the specific schedules, and we align them with our project. There are a bunch of different capabilities that we have developed for our clients. We then share each one as an asset and resource for them to reference and use. You'll see here that we can manage this. We have the projects it's assigned to, and we can share it with anyone, create a link, track the versioning and download it as a source file as well,

[19:30] if we want to share that. We have a bunch of different examples. There are many capabilities in terms of the assets and resources we can create, but ultimately the goal is a consolidated solution that standardizes all of the operating procedures a scheduler goes through to interact with their clients, and helps them enhance their systems and processes to document, record and create systems that let them standardize their procedures. That is the core synopsis of the entire Connect platform. Just for

[20:15] the purposes of this recording, I'm going to continue into a few of the other capabilities of the platform that are more on the back-end side. One is an entire alert system with an agentic alert process that can create any type of rule-based alert based on scheduling notifications, triggered every time a schedule is updated or uploaded into the platform. You can have an agent create any type of alert you want, and there are also a lot of prebuilt alerts that can be customized for your specific needs. You can track your entire activity and log any settings here. One of

[21:00] the key things I want to dive into is the executive admin portal. The executive admin portal tracks the overarching capabilities of the entire platform. Essentially, an executive of the platform would say, "How is this functioning? How can I manage the entire platform and get a general overview of how everything's working?" These are all of the different agents and the health of these agents, so it gives complete visibility into how everything's functioning. Anything that specifically needs your attention can be surfaced. With the agents here, we have our configured agents.

[21:45] We can see the configuration for each one: the system prompt and the model. We can update and change any of these. We see the tools it has access to, and we can version control all of it. If we want to add context to the knowledge base, we can leverage the data sources we have access to and create new skills or knowledge sources that the agent can use. From there, we can see all of the tools and the number of calls. We can update any of these and track the entire activity for the agent as well. This is the entire log history for all of the agents.

[22:30] If we click into one, that is the Update agent. But if we go into... let's do the Project Info Sheet agent here. We'll see that it has all of the tool calls and the turns it runs, and any tool calls it leverages. It gives great granularity into each of these, and you can see the full details of the inputs and outputs for everything. All of this is also available through the executive admin Connect MCP, so agents can, for example, if

[23:15] you're using Claude Code, use the MCP to extract information from the logs and identify any errors or opportunities for enhancement for different agents. Then we have agent quality. We use a grading rubric for how these agents are performing, so over time we can enhance them and make sure they're operating efficiently and effectively. This is great for making sure they stay up to date, and if anything is slipping or needs attention, we can prioritize and focus on it. We have our reference sets, which are our golden sets that we use for specific requirements for how we

[24:00] prefer the agents to respond, and their different capabilities. You can see there are a lot of different grading rules we can give it that rank how well it responds to specific questions or requests from the user. And if there are any updates, enhancements or changes, like adding new skills or changing the model, all of that goes into a review queue where the executive admin approves and submits it before it's validated. We also have self-improvement. As the human analyzes this, and since we have access to the MCP, we can also have

[24:45] an agent process all of the improvements we would recommend for the agents. You can look for specific ways the agents can be improved. For example, for the Project Info Sheet agent, it would say, "Here are some additional recommendations on how it could be improved," from knowledge documents to prompt tweaks to model changes and grading rules. So it's quite robust in terms of enhancing, updating and implementing this. Of course, we can turn on autopilot. We went over the agent logs, which are an entire historical log of how every agent is responding, with all the tool calls and turns.

[25:30] Then we can start analyzing all of the usage across organizations and users. We can identify all of the agents being used, the tools being referenced, which users are using it the most, and which models are being used, to identify token costs, successes and even which clients are using this. We also have the Connect MCP, as I discussed previously. Here it tracks all of the tools we give it the capability to use. You'll see there are a lot of capabilities, from getting files to generating info sheets, searching

[26:15] information and answering questions. This MCP can be tracked to analyze how all of the capabilities within the agentic platform are being used. As users interact with it in their own use cases, they can use the MCP to access the capabilities of the entire platform, and we can track and analyze how people are using it. These updates are the project updates happening on the platform, so we can track them to make sure projects are progressing, along with any associated health. And we have an agent graph for usage and the agents leveraging the

[27:00] different tools and capabilities, so we can track and analyze all of this by user. We have our entire directory, which leads us to all of our different users and the projects they have access to, so we can analyze and track that information. We then give organizations workspaces. Workspaces are assigned, and we can create and assign users and/or organizations to a workspace. This is how we organize and compartmentalize, and assign access privileges and user roles. Each of these workspaces can have feature access turned on or off.

[27:45] Specifically, we're giving access to the agents and to functionality that is typically linked to the Foundry we're using, or to audio transcription. These are feature flags that you can turn on or off for specific organizations or even users. We are also controlling MCP access. For the MCP, we can turn the Schedule Builder agent on or off. That is, whether we want Claude Code or Codex to be able to generate the schedule, and/or whether we use our own Schedule Builder agent to

[28:30] build it. We can also turn on or off our core or full set of tools, which is every single tool within the platform's capabilities, and we can assign this at a per-workspace level as well. Then we assign roles within each workspace: workspace admin, guest and so on. This is our role-based access control, and we invite users as members, guests or admins. Each workspace can then have the organization's custom documentation and resources assigned to its vector database.

[29:15] All of these can be re-indexed and referenced as vectorized embeddings, with similarity search, so the agents can reference them. The agents still pull in the files and documentation; they just use the vectors to extract context, make querying easier, and index and reference exactly which file the information comes from. And then there are the query approvals for the App Builder. When apps query data within the platform, that is where all of that information is tracked and stored. So that is the entire development of

[30:00] the executive admin portal. Of course, we can go back into Connect, go into a workspace, and within that workspace we are brought back into our Connect AI. We also have the ability to use this as an embedded iFrame, where it can be hosted and expanded. If there's any additional information you'd like, I'm happy to share, so let me know if there are any questions. There are a ton of capabilities and functionality in the platform to use as an agentic system to standardize the procedures and processes that schedulers go through, and to have this standard procedure to

[30:45] walk people through and document all of their projects, with a historical log that organizations can leverage and share access to. Everyone can assign files, upload them to their project, and reference them within their agentic system. You can version control them. Then there are the information sheets, which are the entire analysis of the drawing review and file review. This saves organizations and people time across the entire job of reviewing hundreds and hundreds of pages of specifications and drawings, and tracking and analyzing all of the audio recordings and meetings organizations are having. This entire process consolidates all of that into a standard process for what the source

[31:30] of truth is for the project. Then we generate the means and methods. These are the questions that can't be answered from the information that was gathered, so we interact with the client and share that information with them, so they can identify the specific focus on how this project is being built. The info sheet is more about what is being built. To collaborate with the client, you need to understand the how: the processes, procedures and sequence of events that are occurring. So once we have the what, and we put it together with the how, we can generate the schedules for the various types of projects that are required. Users can

[32:15] specify the type of schedule they need to build, generate versions, test different things and interact with it to enhance it, and use Syncify to implement it and make any adjustments as necessary. Once that is the baseline, they can make adjustments or enhancements as they collaborate with the client, do job walks, update the schedule and share that information with the client. As the project progresses, we're linking in all of the data from their different sources of information, whether external third-party data sources, APIs or additional file uploads, to ultimately

[33:00] generate these assets and resources to make informed decisions, educate the client on the progression of the project, and align on collaboration and coordination around a standard, collective source of truth for the project, gathering that insight through interacting with the chat agent here. So feel free to reach out if there are any questions or anything else. I hope you enjoyed it, and I appreciate the time and opportunity. Thank you.