On this page
Before you connect an AI assistant to construction records, decide five things: whose credential it uses, which records and actions those credentials allow, whether it can write at all, who approves anything it prepares, and how you’ll see what it did. The connector technology, whether a Model Context Protocol server or a direct API integration, matters less than those answers.
Assistants are good at the cross-record questions contractors ask every week: which RFIs are holding up change orders, which commitments are over budget, which subs have insurance expiring. Answering those from the source beats answering from screenshots. But a connected assistant can do whatever its credential can do, so set it up the way you’d set up a new hire’s login.
1. Use the person’s own credential, never a shared one
The assistant should act as the person using it, with that person’s permissions. A shared administrator token makes every answer, and every change, look like the administrator’s, and it lets the assistant see records the person never could. Credentials go in the client’s protected settings, not in a prompt or a shared file.
2. Scope it to the task
Grant the narrowest scopes that do the job: read RFIs and change events on one project, not everything in the company. Expect the system to keep enforcing its normal rules on every call: company, project membership, role, enabled tools and record visibility. A connector that describes hundreds of operations isn’t granting access to them; the system behind it still decides.
3. Start read-only
Turn writes off for the first weeks. Ask the questions you want answered and check the answers against the records. Reads go wrong in useful ways: a filter that misses a status, a first page treated as the whole list. You want to find those before anything changes data.
4. Keep approvals with people
When you do allow writes, start with drafts that a person reviews. Anything that commits money, changes a contract or releases a payment should be approved by a named person under your normal approval limits. That’s the human-in-the-loop principle, and it’s also basic segregation of duties: the preparer, even an automated one, shouldn’t approve its own work.
5. Make it reviewable
You should be able to answer “what did it read, what did it change, and under whose credential” after the fact. Check that changes made through the connection land in the same audit trail as changes made in the app, and that you can revoke a connection without rotating everyone’s credentials.
Worked example
Illustrative: a project engineer wants a Monday summary of open submittals at risk on her job. Her admin issues a token tied to her own user, scoped to read submittals and the schedule on that one project. She configures it in her assistant’s protected settings with writes disabled. The first week, the summary misses two items because the assistant read only the first page of results; she adds “check every page” to her standing request and compares the next run against the submittal log. By week three it matches, and the team uses it. Nobody has enabled writes, because the job never needed them.
Checklist
| Question | Good answer |
|---|---|
| Whose credential? | The person’s own, kept out of prompts |
| What scope? | Only the records and actions the task needs |
| Writes? | Off until a specific reviewed task needs them |
| Approvals? | A named person for money, contracts and payments |
| Permissions enforced? | By the system on every call, not by the connector’s list |
| Visibility? | Calls and changes recorded; connections revocable |
Common mistakes
- Connecting with an administrator token “to save time.”
- Enabling writes before reads have been checked against the records.
- Treating a connector’s catalog of operations as a list of what the user may do.
- Pasting credentials or whole exports into chat.
- Letting an assistant approve its own drafts.
How os.construction handles it
An MCP connector and an agent CLI are in Preview as a local developer preview. They run from a checkout of the os.construction repository and call the REST API with the person’s own API token, so every call goes through the API’s normal checks on scopes, company, project membership, role and enabled tools. The connector keeps the initial tool list small (search operations, describe one, then call it), returns results a page at a time, and keeps writes off unless they’re explicitly enabled. Hosted connections with browser consent, which a user can review and revoke under the account’s connected apps, have passed local checks but aren’t publicly released. Built-in AI agents that draft work for approval remain planned. See MCP permissions and troubleshooting and the CLI preview.
FAQ
Can I connect ChatGPT, Claude or another AI assistant to my construction software?
If the software offers an API, and especially an MCP connector, many AI clients can connect to it. Whether you should depends on the controls: the connection should use the person's own credential with narrow scopes, enforce the software's normal permissions on every call, start read-only, and leave approvals with people.
What is the safest way to start?
Read-only, on one test project, with a credential scoped to the records the task needs. Run the questions you actually want answered, check the answers against the records, and only then consider broader scopes or write access for specific, reviewed tasks.
Should an AI assistant be allowed to approve invoices or change orders?
Keep approvals that commit money, change a contract or release a payment with a named person. An assistant can prepare, check and summarize; the approval should stay with someone accountable under your approval limits and segregation of duties.
What should you never paste into an AI chat?
API tokens, passwords and other credentials. Configure credentials in the client's protected settings instead. Also be deliberate about pasting private records: a connection that reads them under permissions is easier to control than copies in chat history.
Share this article