Skip to content
be-human.ai
← Back to the journal

AI by industry

AI for an Engineering Firm: Project Files, RFIs and Memory That Compounds

How small engineering firms can use AI agents for RFI tracking, submittal logs and project file hygiene, with clear approval limits and one success test.

Be Human typographic cover with the title: AI for an Engineering Firm: Project Files, RFIs and Memory That Compounds
Conceptual illustration created with AI · Be Human

For a small engineering firm, AI is most useful when it keeps the project record accurate: which RFIs are open, which submittals are waiting on whom, and which file holds the current answer. A well-scoped AI agent can watch those logs, flag overdue items and draft follow-ups for a person to review, while anything that changes scope, cost or schedule stays with a named approver. The record also becomes more valuable over time, because a clean project memory gives the next model something accurate to read.

Key takeaways

  • Start with one job, usually keeping RFI and submittal logs current and visible, rather than asking an agent to handle design work.
  • An agent can only be as reliable as the folder structure, naming and status fields it reads, so file hygiene comes first.
  • Put approval boundaries in the first scope: substitutions, design basis changes, schedule commitments and formal responses go to a named person.
  • Define one observable success test, such as whether every open RFI has an owner and a response date at the start of each week.
  • Structured project memory compounds: each corrected record makes the next answer more accurate, whichever model reads it.

Why RFI and submittal tracking breaks first in small firms

Small firms rarely lack the knowledge to run a project well. They lack a single place where the status of that knowledge is kept. A contractor sends a request for information by email, a designer answers from a site visit, and the answer is confirmed by phone and then forgotten in the log. Submittals follow the same path: a product data sheet arrives, comes back with comments, and is resubmitted under a new file name while the log still shows the first version.

The gap between what happened and what the log says is where delay and rework start. Teams usually discover it late, when a fabricator orders against an old detail or a contractor asks why a response is three weeks old. Nobody made a bad decision in that sequence. The record simply stopped matching the work, and no one had time to reconcile it.

This is why the first useful application of AI in an engineering office is often unglamorous. It is the job of reading correspondence, matching it to open items, and saying clearly where the two disagree.

What an agent should own and what it should never decide

The boundary between routine administration and professional judgment should be written down before any tool is connected. A practical split looks like this:

  • Owned by the agent: logging incoming RFIs and submittals, reminding owners of approaching and overdue due dates, drafting a response summary for the engineer to edit, checking submittal lists against specification sections, and flagging missing attachments or mismatched revision letters.
  • Reserved for a named person: accepting a substitution, changing a design basis, committing to a schedule or cost, sending any formal response to a contractor, and closing an item that affects construction.
  • Shared, with review: linking a correspondence thread to a log entry, where the agent proposes the link and a project engineer confirms it.

The agent should have read access to the project folders it needs and write access only to the log fields it is meant to maintain. Anything outside those fields should stay read-only. A narrow scope is easier to test, easier to explain to the team and easier to pull back if something goes wrong.

A step-by-step plan for the first file audit

Before any agent runs, spend a short, deliberate effort on one active project. The goal is not a perfect archive. It is a reliable starting record that a person and a machine can both read.

  • Choose one active project with a live RFI log, a submittal log and a folder tree that the team actually uses.
  • Export both logs and mark every item that is closed in email but open in the log, and the reverse.
  • Check that each record has an owner, a date received, a due date and a link to the controlling document or drawing revision.
  • List the three questions the team asks most often about this project, such as the current bolt specification or the approved finish schedule, and note where each answer lives.
  • Decide which fields the agent may update and which only people may edit, then write that decision into the scope document.
  • Set one weekly check: a list of open items past due, sent to the project lead every Monday morning.
  • Run the agent in draft mode for at least two review cycles, so every outgoing message is read by a person before it leaves the office.

The audit usually takes less effort than teams expect, because most of the mismatches are obvious once they are listed together. The value is that the record becomes trustworthy enough to build on.

Illustrative scenario: a connection detail that stayed open

The following scenario is illustrative and does not describe a specific client. A small firm is working on a commercial fit-out with a steel contractor. The contractor asks an RFI about a connection detail, and the project engineer answers by phone, then confirms the answer in a text message. The log still shows the item as open, so the contractor's coordinator keeps chasing it.

Two weeks later, a submittal arrives for a substituted fastener. Nobody links it to the RFI, because the submittal sits in a different folder and carries a different reference number. An agent with read access to the correspondence folder and the logs would have flagged the mismatch on its weekly pass. It would have drafted a short note for the engineer: the RFI appears open, a related submittal exists, and the text confirmation suggests the answer was given. The engineer would confirm, correct or reject the link. Nothing would be sent to the contractor until the engineer approved it.

The difference is not speed alone. The record would have shown, in one place, what was asked, what was answered, and what was submitted in response.

How project memory compounds when the next model reads it

Models change. The project record should outlast them. An agent does not need to hold an entire project in its head. It needs a small, current, well-labeled set of records for each task, and the discipline of context engineering is largely about choosing that set carefully. Anthropic's engineering guidance on context for agents describes the same principle: give the model the information relevant to the current step rather than everything that exists.

For project facts that change weekly, retrieval over a clean, indexed project record is usually the better pattern than training or fine-tuning a model on those facts. Fine-tuning is poorly suited to information that changes often, because the knowledge goes stale as soon as the next revision arrives. Retrieval keeps the answer tied to the current document, and the citation tells the reader where the answer came from.

The compounding happens in three places. Each closed RFI with a clear resolution note becomes a reusable reference for the next similar question. Each corrected log entry removes a source of error the next agent would otherwise inherit. And each evaluation set, built from questions the team really asked on past projects, gives the firm a fixed test to rerun whenever the underlying model or the instructions change. Without that test, a model upgrade can quietly make answers worse, and no one notices until a contractor does.

Permissions, untrusted documents and the risks to manage

The documents that flow through an engineering office are not all trustworthy. Contractor submittals, scanned markups and forwarded emails can contain text that tries to direct the reader, including an automated reader. Treat document content as data to be summarized and checked, never as instructions to follow. The OWASP guidance on prompt injection prevention describes this separation, and it should shape how the agent is instructed and how its outputs are reviewed.

Access should follow the principle of least privilege. The agent reads only the project folders in scope, writes only to the log fields it owns, and cannot send outbound email without approval. The OWASP authorization guidance is a useful reference for checking that each permission is granted deliberately and reviewed when people or projects change. The NIST AI Risk Management Framework offers a structure for naming these risks, assigning owners and deciding what level of monitoring each one needs.

Be Human handles this kind of work as a managed operation. An engagement starts by defining one useful role, the memory and tools that role needs, the approval boundaries and an observable success criterion. Ongoing operations can include monitoring of the logs, recurring evaluations against past RFIs and submittals, integration maintenance, permission reviews when staff change, and controlled updates to the agent's instructions. The service is remote and available in English and Portuguese.

Where to start

Most small firms do not need a long program to begin. They need one active project, one honest audit of its logs, and one agent role with clear limits. Pick the project where a stale RFI would cost the most, and start the audit there. The free Be Human AI diagnostic can help you find the first task worth handing to an agent.

Frequently asked questions

Can an AI agent replace the project engineer who tracks RFIs? No, and it should not be scoped that way. The agent can log items, watch due dates, draft summaries and point out mismatches between correspondence and the log. The engineer still decides how each request is answered, approves every formal response and owns the professional judgment behind the design.

Do we need to reorganize every project folder before an agent can help? Not every folder, and not all at once. Start with one active project, export its logs, and fix the mismatches that matter most, such as missing owners, missing due dates and submittals without a link to the controlling revision. Broader cleanup can follow once the first record is reliable.

Is it safe to let an agent read contractor documents? It can be, if the setup is deliberate. Read access should be limited to the project folders in scope, document content should be treated as data rather than instructions, and outbound messages should wait for human approval. Permissions should be reviewed whenever a project closes or a team member changes roles.

How do we know the agent is doing the job well? Define the success test before the agent starts, for example that every open RFI has an owner and a response date at the start of each week. Build a small evaluation set from questions your team actually asked on past projects, rerun it after any change to the model or instructions, and review the flagged mismatches with the project lead each week.

Your next step

See where an AI agent fits in your company first.

Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.

Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →