Major

Airtable Record Enrichment Agent for Reliable Field Filling

Build an Airtable record enrichment agent that fills missing fields, scores confidence, and routes low-confidence updates for review using external data.

Ritvij Gautam
team collaborating on shared documents (Airtable AI agents and automations)

An Airtable record enrichment agent fills missing fields in your base by gathering data from public sources and other systems. It scores its confidence in each enrichment and holds low-confidence updates for human review before writing back. This guide explains how to build and manage such a process with Apollo, Google Drive, and Slack.

This guide covers one Airtable process end to end. For the Airtable API guide, connection setup and the full list of Airtable use cases, see More Airtable use cases.

Why This Process Breaks Today

Many businesses use Airtable bases to track vendors, leads, and content requests. Records often arrive incomplete: details are missing and teams have to hunt down company descriptions, contact roles, document links or scoring information. Manual fixes are unreliable. Team members fetch data from varying sources or forget to update records, resulting in inconsistent and outdated entries. When external enrichment is attempted, scripts either overwrite good data or fill records with unreliable information. Low-confidence guesses end up in production, causing confusion later.

The Systems and Data Involved

Airtable Structure and Endpoints

  • Airtable Base: Contains tables like Leads, Vendors, or Content Requests.
  • Records: Represent the entities being enriched (one per row).
  • Fields: Attributes to fill, like Industry, Company Size, Primary Contact Email.
  • API endpoints:
  • GET /v0/{baseId}/{tableName} (list records)
  • PATCH /v0/{baseId}/{tableName}/{recordId} (update records)
  • Event: New record creation (tracked via polling or webhook if using an intermediate tool).

Other Systems

  • Apollo: Used to find company information and contact details. Query via Apollo’s REST API endpoints, such as /v1/organizations/search and /v1/people/search.
  • Google Drive: Serves as a source for missing documents or assets. Use the Drive API /files endpoint to locate by name or keyword.
  • Slack: Sends notifications to relevant teams when low-confidence enrichments need review.

What is Code vs. What is Agent Judgment vs. What Needs Human Approval

  • Code:
  • Reads records from Airtable.
  • Calls external APIs (Apollo, Google Drive) to query data.
  • Compares new data to existing fields.
  • Writes updates automatically when confidence is high.
  • Routes updates for review via app or Slack when confidence is below a threshold.
  • Agent Judgment:
  • Determines if candidate data is a plausible match for the record.
  • Scores confidence in the enrichments. For example, a contact found on Apollo with a matching company domain but slightly different name.
  • Flags ambiguous or partial matches for human review, instead of directly updating.
  • Human Approval:
  • Reviews records that were flagged as low-confidence by the agent’s scoring.
  • Accepts, edits, or discards proposed enrichments in a controlled app view.

Worked Example: Walking Through a Realistic Record

Suppose you are enriching a Leads table. A new record arrives:

| Name | Company | Email | Industry | Company Size | Deck Link | |--------------|--------------------|-----------------|----------|--------------|-----------| | Jane Miller | Sunset Logistics | (blank) | (blank) | (blank) | (blank) |

Step 1: Code detects missing fields.

  • Scans for empty Email, Industry, Company Size, and Deck Link.

Step 2: Agent queries Apollo and Google Drive.

  • Uses Apollo’s /v1/organizations/search endpoint with Sunset Logistics.
  • Retrieves company info: Industry is "Freight Transport". Company size is "201-500".
  • Person search in Apollo for "Jane Miller" at that company. Finds two Janes: one with matching job title, one with a different spelling ("Janet Miller"), both possible.
  • Queries Google Drive /files for "Sunset Logistics Deck". Finds a PDF with matching date from a known contributor.

Step 3: Agent scores confidence per field.

  • Industry: High confidence (exact match).
  • Company Size: High confidence.
  • Email: Low confidence, since more than one "Jane Miller" found, and email domains differ.
  • Deck Link: Medium confidence (match on title and user context, but file owner is not in internal directory).

Step 4: Writes and holds.

  • Writes Industry and Company Size directly via Airtable PATCH endpoint.
  • Holds Email and Deck Link for human review.
  • Triggers a review task in an app or sends a detailed Slack message, listing candidate emails and drive file URLs, asking for confirmation.

Step 5: Human reviews and resolves

  • Reviewer picks the correct email and confirms the document. App writes these back with attribution.

How to Build It on Major

Major lets you formalize this process using three things: an app, an agent, and a workflow.

App

  • Presents held enrichments to reviewers.
  • UI shows the target Airtable record, candidate data, scores, and a resolution panel: Accept, Edit, or Dismiss per field.
  • Log of who performed which review, with snapshots.

Agent

  • Encapsulates the logic for matching, querying, and scoring:
  1. Watches for new or incomplete Airtable records using the GET endpoint and change detection.
  2. Calls Apollo and Google Drive APIs with necessary criteria.
  3. For each field, attempts to resolve and assigns a numeric/percent confidence based on match strength, source authority, and field context.
  4. If confidence above a set threshold (for example, 0.8) updates Airtable directly.
  5. Otherwise, triggers a review event, storing the pending changes and scores.
  • Judgment includes flagging plausible false positives (like common names or mismatched domains) and selecting "maybe" candidates without committing.

Workflow

  • Orchestrates the process:
  • Trigger: New or updated record in Airtable (polling or via webhook).
  • Sequence:
  1. Passes record to Agent for enrichment.
  2. If review required, appends it to a review queue and, optionally, sends a Slack notification with a review link.
  3. When review is complete, writes back to Airtable. Marks completed tasks as resolved.
  • All actions logged under scoped credentials per connector.

What to Measure

Practical metrics help you tune this process over time:

  • Completion Rate: Percentage of incomplete records that become fully enriched.
  • Human Review Load: Proportion of updates held for review, and average reviewer response time.
  • Edit Acceptance: How often reviewers approve, modify, or reject agent-suggested values. High rejection means confidence scoring needs adjustment.
  • Field Accuracy: Spot check enriched values versus ground truth or manual research.
  • Incidence of Incorrect Overwrites: Look for cases where an incorrect deterministic update gets through, so you can tighten agent guardrails.

Guardrails (What the Agent Must Never Do)

The agent needs clear constraints:

  • Never overwrite an existing Airtable field with new data unless it is confident and the field is blank or a reviewer approves.
  • Never propose values from untrusted or ambiguous sources. For example, if two contacts match only loosely, hold both for review.
  • Never generate or hallucinate data (such as making up an email address from a guessed domain).
  • Never cascade changes based on a low-confidence match. For example, do not update Company Size if the company match is unclear.
  • Always log every attempted update, including values, scores, and source, with reason for review versus direct update.

This approach balances automation with safety and gives everyone a clear log of what changed and why.

Frequently asked questions

How does the Airtable record enrichment agent decide when to hold a change for review?

The agent scores each candidate value on confidence, based on match quality, source authority, and consistency. If the confidence falls below a set threshold (e.g., 0.8), it holds the update for review in the app instead of writing directly to Airtable.

What if Apollo or Google Drive return multiple candidates for a missing field?

The agent presents all plausible candidates with their confidence scores and supporting context in the review app, so a human reviewer can make the final selection before the value is written back to Airtable.

What actions are logged by the enrichment process on Major?

Major logs every API call, data fetch, enrichment attempt, confidence score, and write-back to Airtable, including whether each update was made directly or after human review. The log includes user attribution for approvals or edits.

Can this process avoid overwriting fields that were already manually populated?

Yes. The code and agent are designed to skip enrichment for fields that are already filled, unless you choose to allow explicit overrides through a review or approval path. This prevents accidental data loss.

Start building on Major

Connect Airtable, describe the process, and Major builds the app that holds its state, the agent that makes the judgment call and the workflow that runs it, with scoped access and an audit log from the first deploy.

Frequently asked questions

Can an AI agent update records in Airtable using Major?
Yes, an agent can update Airtable through Major using the PATCH /v0/{baseId}/{tableIdOrName} endpoint. Human approval steps can be built in if required.
How do Major workflows interact with Airtable data?
Major workflows read from and write to Airtable using its API endpoints. Orchestration flows let you connect actions in Airtable with other tools, while always keeping Airtable as the source of truth.
Is authentication handled through API keys or OAuth?
Airtable now requires tokens for API authentication, sent as Bearer authorization. Legacy API keys are not supported, and tokens must be scoped for the relevant base or workspace.
How do Major agents complement Airtable's built-in AI features?
Airtable's built-in AI features handle data tasks directly in the table. Major agents operate externally, adding context-aware judgment, chaining multiple steps, and allowing approvals for sensitive actions.
What are the rate limits for Airtable API access?
The API allows 5 requests per second per base and 50 per second across all a user or service account's tokens. Exceeding this results in a 30-second wait after a 429 error.