Tag: MCP

The Field Agent

(Identity, Input, and the Digital Twin of the Dirt)

We’ve spent the last month teaching an AI agent (the Digital Scribe) to read handwritten 1880 census cursive and build a social graph. It was a rigorous exercise in high-integrity, atomic knowledge mapping.

You might wonder what 19th-century ledgers have to do with a modern harvest. The answer is Identity. The same principles we used to track a person through history—giving them a unique, permanent ID and linking them to their family and home—apply directly to tracking a vineyard block over time. We aren’t just logging data; we are building a “life story” for your land.

But it’s mid-summer in Oregon, and the ledgers are dusty. The Pinot Noir and Maréchal Foch are heavy on the vine. It’s time to move from forensic history to the real-time resilience of The Agile Harvest.

The Mid-Summer Anxiety (The 70% Problem)

It’s 6:00 AM. You’re walking Row 12, checking the clusters. The forecast says 95°F by noon. The vineyard looks beautiful, but last night, you were looking at your contracts. You have 100 acres of prime fruit, and only 30% of it is spoken for.

The “70% Anxiety” is real. In a traditional model, that 70% unsold acreage is just risk—money you’ve spent on labor and trellis maintenance that might never come back. In a Sovereign Vineyard, that’s not risk; it’s a linked set of opportunities.

What do I mean by “Sovereign”? It means you own the “Brain.” Your sugar levels, your yields, and your profit margins stay on a local server you control—not in a third-party cloud app that sells your aggregate data back to big-box competitors.

A rugged tablet displays a precision block map of a vineyard. A farmer's gloved hand holds a refractometer reading "13.5 Brix" next to a bunch of Pinot Noir grapes. Morning sunlight illuminates the scene.
Tactile Capture. The Sovereign system begins with high-integrity data. Whether you log it via a handheld refractometer or an advanced sensor array, the Field Agent’s goal is to turn that reading into a decision point.

The Clipboard-to-Sensor Agnosticism

A core pillar of The Agile Harvest is that the AI doesn’t care how the numbers get in, as long as they are accurate. This isn’t about expensive sensor arrays; it’s about Input Agnosticism.

  • The High-Tech Path: You have LoRaWAN soil moisture probes and automated brix samplers reporting every hour.
  • The “Flannel & Clipboard” Path: You are walking the rows, crushing a grape onto a prism, and typing “13.5 Brix” into a simple chat window on your phone.

To the Digital Scribe, a number is just a number. Whether it comes from a $5,000 automated probe or a handwritten note, once it enters the Knowledge Graph, it becomes a Decision Point.

The Field Agent in Action: The Reasoning Loop

This is where the “Field Agent” metaphor cashes out. Your agent isn’t just a database; it’s a strategic advisor watching the “trajectory” of your fruit.

A Mermaid chart showing a central 'Vineyard Block' node linked to static identity nodes and a '13.5 Brix' observation. An 'Agent Reasoning' box analyzes the brix and recommends a 'Verjus Market Pivot' node. Solid lines show relationships, and dashed lines show agent analysis.
The Pivot Graph. This diagram illustrates how the Scribe moves from data to decision. The static Block Identity (Foch/Jory Soil) is the anchor. When a new Observation (13.5 Brix) is linked, the Agent reasons across its knowledge—contracts, weather, brix—and creates a new, prioritized link to a Market Pivot (Verjus) opportunity.

The Sunday Morning Exchange:

Farmer: “Scribe, I just logged a 13.5 Brix and pH of 3.0 on the Foch block. It’s early, but the heat is coming.”

Field Agent: “Copy that. That’s a 2-point sugar jump since Tuesday. Acidity is still very high. I’m cross-referencing our contract list: we still have 15 tons unallocated on this block. My weather tool predicts three days of 95°F+.”

Farmer: “What are my options if we don’t hold for the wine contract?”

Field Agent: “The ‘Verjus Window’ is open. Verjus (unripened green juice) requires high acid and low sugar—exactly what we have today. We are scheduled for green harvesting (thinning fruit) on Tuesday anyway. Instead of dropping that fruit to the mulch, we can divert it to the culinary market. Based on current spot prices, that 70% risk just became a 20% early-season revenue win.”

The Road Ahead

Identifying the “Verjus Window” is just the first step in The Agile Harvest. By treating your vineyard block as a “Digital Twin” with its own identity and history, we’ve built the foundation to pivot before the birds get your crop. Next, we’ll look at the “Pivot Engine” itself—how we connect our local graph to global market APIs to find the highest value for every cluster.

Digital Scribe Series (A Sovereign Path)

Are you facing similar mid-season jitters with unsold inventory or shifting markets? How are you handling the gap between what you grow and what you’ve sold? Reach out on LinkedIn and let’s start a conversation about how local-first AI can help you find your next “Agile Harvest” opportunity.

Facebooktwitterredditlinkedinmail

The Death of Note-Taking and the Rise of the Digital Scribe

In our previous series, we built the Sovereign Vault to verify truth in existing records. But as we move deeper into the age of AI, we face a massive unsolved problem: the unstructured nightmare of human history. Millions of documents exist as “silent” pixels—scanned but not understood.

Today, we launch a new series: The Digital Scribe. We are moving from the right side of the value chain (answering questions) to the left side: building the knowledge systems that answers come from.

Beyond the Chatbot: AI as Knowledge Steward

Most AI implementations treat the Large Language Model (LLM) as a general-purpose assistant. The Digital Scribe is different. It is an Infrastructure Layer designed to capture, structure, and preserve human knowledge.

By using the Model Context Protocol (MCP), we decouple the “Brain” from the “Tools”. This allows us to “hire” specialized personas—like our Senior Paleographer—to transform 19th-century cursive into structured, queryable data.

The Challenge: Temporal HTR

Handwritten Text Recognition (HTR) for historical documents is notoriously difficult. Ink fades, cursive loops vary, and 1880 enumerators loved their shorthand. A standard “chatbot” will guess; a Scribe uses a governed protocol.

We have built a Temporal HTR Server that bridges the gap between raw pixels and structured archives.

The Capture Pipeline

Architectural diagram showing the Digital Scribe pipeline from manuscript scan to structured knowledge archive.

Implementation: The Sovereign Ingestion

Our system isn’t just “reading” text; it’s enforcing Governance and Provenance. We use Pydantic v2 to ensure every record captured from the 1880 Census meets strict archival standards.

One of the most human elements of these ledgers is the “Ditto Mark” (do.). To a simple OCR, it’s noise. To our Scribe, it’s a data-link.

# The Scribe's Ditto Resolution Logic
def resolve_ditto_marks(self, previous_record: "Census1880Record | None") -> Self:
"""Logic for inheriting values from previous_record when ditto marks are detected.

When a dittoable field contains a ditto mark, copies from previous_record.
Raises RecursiveDittoError if previous_record also has a ditto in that field
(chained ditto); forces the orchestrator to resolve records in chronological order.
Returns a new record; does not mutate self.
"""
if previous_record is None:
return self

updates: dict[str, str] = {}
for field in DITTOABLE_FIELDS:
val = getattr(self, field)
if val in DITTO_MARKS:
prev_val = getattr(previous_record, field)
if prev_val in DITTO_MARKS:
raise RecursiveDittoError(
f"Chained ditto in {field}: previous_record also has ditto {prev_val!r}. "
"Resolve records in chronological order."
)
updates[field] = prev_val

if not updates:
return self
return self.model_copy(update=updates)

Why This Matters: From Pixels to Provenance

Comparison: Traditional OCR vs. The Digital Scribe

Feature Traditional OCR The Digital Scribe
Focus Answering immediate questions Building the knowledge base
Context Single-page/Isolated Cross-record/Temporal
Handling “do.” Ignored as noise Resolved as a data-link
Output Flat text files Structured Knowledge Graphs
Integrity Statistical “best guess” Governed Provenance & Audit Trails

The Digital Scribe represents a shift in how developers think about AI systems. Instead of focusing on prompts, we focus on data structure, normalization, and relationships.

By implementing Recursive Ditto Resolution, we solve for Provenance. We aren’t just creating a text file; we are creating a verifiable knowledge archive.

Whether you are an archivist, a researcher, or an enterprise architect, the “Scribe” pattern is the only sustainable way to turn unstructured data into institutional memory.

Next Up: The Knowledge Graph Ingestor

Capturing a single row is just the beginning. Real history doesn’t live in a spreadsheet; it lives in the relationships between people, places, and time.

In our next installment, we move beyond flat tables to build the Knowledge Graph Ingestor. We will explore:

  • Entity Extraction: How the Scribe identifies families, neighborhoods, and occupations as interconnected nodes.
  • The Cross-Referencer: Using MCP to link our 1880 Salem records with external historical gazetteers and birth records.
  • Persistent Memory: Moving from temporary JSON captures to a permanent, queryable JSON-LD knowledge store.

We’ve taught the AI to read; now we’re going to teach it to remember.

Facebooktwitterredditlinkedinmail