Google’s Second Index
I remember analyzing Palantir’s business model back in 2019–20 and finding its strategy almost counterintuitive. At a time when Google and Meta had built some of the most valuable cash machines in history by serving consumers at massive scale, Palantir was doing the opposite: going deep into the enterprise and tackling complex software problems most companies did not want to touch.
That became its edge. Palantir’s land-and-expand model was built on a simple premise: solve hard problems first, embed deeply into the organization, then expand from there.
The forward-deployed engineer became central to that model, and Palantir effectively defined the category.
Over the last four years, I have argued that this role matters because enterprise AI is not primarily a model problem. It is an integration problem. Models have to connect with fragmented data, legacy systems, workflows, governance structures, and humans operating in highly constrained environments.
What has changed is that everyone now wants the enterprise. The AI labs have pivoted toward it, hyperscalers are moving deeper into it, and the enterprise layer has become one of the main battlegrounds of the AI stack. This is the foundation of my Enterprise Alliance thesis and the broader Enterprise AI Coordinate System.
Google is now entering the same arena from the opposite direction. It spent most of its history building consumer-scale search infrastructure. Now it is attempting to repurpose that machinery to solve the enterprise context and integration problem.
Google’s bet is that enough of the forward-deployed engineer’s work can eventually be automated through software. That may work, and if any company has the technical DNA to attempt it, Google is an obvious candidate.
But I do not think the forward-deployed engineer disappears.
More importantly, that may be the wrong question.
The real question is: what new enterprise infrastructure makes human-AI collaboration reliable enough for complex, regulated, high-stakes environments?
This piece is part of The Enterprise AI Coordinate System.
Enter The Second Index
Every AI lab is hiring forward-deployed engineers to hand-structure the enterprise. Google is betting it can automate them away, because it has run this exact play once before and won a category with it.
Two models for organizing a corpus are competing for the enterprise, and only one of them is new. The split surfaced this month in The Information, which laid out how far the major AI companies will go to make corporate data usable by their models, and how sharply Google has chosen to break from everyone else.
In the first model, you hire people. The role is the forward-deployed engineer, a term Palantir popularized for specialists who embed with a customer to wire messy, proprietary data into something an AI can reason over. Following that playbook, OpenAI, Anthropic, Microsoft, and Amazon are now spending billions to hire them by the thousand.
The work is unglamorous and essential: reconciling the four definitions of “gross revenue” living in four systems, mapping which tables mean which things, and teaching the model the distinction before it routes an invoice or onboards a hire. It is careful, expensive, linear labor. Every deployment consumes engineer-hours, and the next one starts again near zero.
In the second model, you automate the people away. That is the position Google staked out in the same reporting through Andi Gutmans, the Google Cloud vice president who runs its database and data products, and the executive who would own this strategy if anyone does.
Google is hiring some forward-deployed engineers of its own, he told The Information, but it is automating the core of what they do: the labor of organizing a company’s data so agents can use it.
His justification is the tell. You cannot, he argues, hire your way to full coverage. Activating all of an enterprise’s data requires a level of headcount no company can afford, so the only route to it is software. He points to a customer arriving with twenty thousand tables to make agent-ready, a job no achievable number of data stewards ever finishes.
What Google’s automated engineers produce, in his telling, is what the human ones did, but at machine scale. They read across a customer’s files, contracts, and databases to work out how everything relates, then emit context-rich structures, including knowledge graphs and semantic layers, that let an agent handle multi-step tasks such as routing invoices or onboarding employees without re-deriving the meaning of the data every time.
The reporting’s headline case is Virgin Media O2, the British telecom, which used Google’s agents to connect twenty thousand separate datasets, work a Google spokesperson framed as removing thousands of manual hours.
The product is called Knowledge Catalog, and Gutmans casts it as Google’s edge over Palantir, which announced a similar AI-powered engineer earlier in the year, because Google can combine the catalog with DeepMind’s research and turn Gemini on its own agents to check their work.
He also concedes the agents are not foolproof. Customers still assign people to vet the output, and the human role is supposed to shrink over time: first a period where people step in to say yes or no, then, as the system accumulates context, something closer to fully automatic.
That justification is not a product claim.
It is Google’s founding thesis, restated twenty-seven years later.
The forward-deployed-engineer strategy and Gutmans’s remarks were reported by The Information. The product mechanics, the “$42 problem,” and the knowledge-gap loop below are drawn from Google Cloud Next ’26 sessions and Google Cloud documentation.
1998, Again
The web had the same problem the enterprise has now: too much unstructured material, growing too quickly for people to organize by hand. The dominant answer in the late 1990s was the directory, with Yahoo’s editors and the volunteers of the Open Directory Project cataloguing the web link by link into a taxonomy maintained by humans.
It was the forward-deployed model applied to the internet: judgment, on-site, one entry at a time.
Google’s insight was that the directory could not scale against an exponential corpus, and did not need to. Crawl everything, resolve what the pages are about, build an index, rank by relevance to intent, and the human catalog becomes redundant. The company that industrialized the automated structuring of a chaotic corpus won the category outright, and the directories became a footnote.
The forward-deployed engineer is the directory editor of the enterprise-AI era.
Gutmans’s argument is the crawler argument ported inside the firewall: you cannot hand-catalog your way to full coverage, so the structuring itself has to become software.
The Virgin Media O2 result is the shape of the claim, if not yet its proof. One vendor case is a direction, not a verdict, and it says nothing about the part of the estate a company has never queried.
What the Machine Actually Does
The product behind this bet is Knowledge Catalog, and it is worth being precise because the mechanism is where the strategy stops being a slogan and becomes testable.
It is not a new product. Google’s own team opens its launch by setting the record straight: this is Dataplex, renamed in April 2026 and repositioned from a governance tool for data engineers into what it calls an always-on context engine for agents. The underlying APIs did not change.
The positioning moved much further than the code did, which is itself the strategic disclosure.
Google decided the metadata layer was no longer plumbing. It was the prize.
Google’s own analogy gives the game away. It describes the enterprise as a map of roads, and the agent as a self-driving car capable of traveling from any point to any other but unable to do so intelligently until something tells it where those points are. Context is that map.
The company reaching for a maps metaphor to explain enterprise AI is, not incidentally, the company that owns the map.
But the deeper admission comes next: the map is not actually stored anywhere. It has to be assembled from signals scattered across every system.
Which means Google has to manufacture the structure it intends to own.
The machine runs on three pillars, in Google’s own naming.
Aggregation
Knowledge Catalog harvests metadata from Google’s own estate, including BigQuery, AlloyDB, Spanner, Cloud SQL, Looker, and Firestore. More importantly, it reaches beyond Google into unstructured files and rival catalogs including Collibra, Atlan, SAP, DataHub, and Ab Initio, with bidirectional exchange where supported.
The design intent is plain: leave no silo uncrawled, including silos that belong to competitors.
Enrichment
This is the part that begins to replace the forward-deployed engineer.
Gemini generates natural-language descriptions of tables and fields, recommends glossary terms, and performs the two moves that matter most: inferring relationships between assets by mining query logs, and proposing validated SQL patterns that encode how a business actually computes a thing.
The relationship inference is explicit about its signal. The system reads query logs, then applies the model to surface joins no schema declares. Extend the same machinery to unstructured content and it can extract entities and relationships from documents that were never tabular to begin with.
Retrieval
Agents pull that context through an API at query time, over a semantic-search layer Google explicitly says is built from its search stack. In its own framing, Google is a search company, and it has moved the same machinery inside the catalog.
Access is inherited from source systems: an agent sees only what its caller is authorized to see.
Read the three pillars back and the architecture is unmistakable:
Aggregate → enrich → retrieve.
Against the enterprise instead of the web. Harvest, resolve, serve, with the model now helping perform the interpretation once supplied by humans.
The moat in search was never just the algorithm. It was the index, the structured layer between the query and the corpus that decided what the ranking ever got to see. Knowledge Catalog is an attempt to build that same layer, one per customer, inside the firewall.
Google says as much on stage. Every agent it ships in its own data cloud is built to hit the catalog for context first, before it does anything else.
The context layer is not another feature in the stack.
It is the thing the rest of the stack now asks permission from.
The $42 Problem
The best illustration of what this machine can and cannot do came not from Google but from a customer on its stage: a Bloomberg Media team walking through what they called the $42 problem.
Ask an agent for monthly net revenue. Net revenue is earned money minus transactional expenses; the SQL itself is undergraduate. The agent finds the billing table, finds the disputes table, writes clean, syntactically perfect code, and returns a number that is wrong.
The number is wrong because this particular company’s payments vendor charges a forty-two-dollar fee on every disputed transaction. The rule is contract-specific, lives in no schema, and was documented once in a 2017 wiki page whose author has since left the company. A capable human analyst, handed the same tables, made the identical mistake for the identical reason.
The failure was not a data problem. It was a knowledge problem, and the knowledge was in nobody’s database and nobody’s head that was still on payroll.
This is the wall every automation bet eventually hits. Structure inferred from schemas and query logs can recover what the organization does. It cannot recover a rule that lives only in a lapsed contract, an old wiki page, or a departed employee’s memory.
Usage is not authority.
No amount of crawling the data plane surfaces the forty-two dollars if nothing in that data plane knows it exists.
Google’s answer is the genuinely clever part, and it deserves credit before it gets its caveats.
The customer built a second agent, a knowledge-gap agent, whose job is to watch the first one fail. It reads the failed query, the user’s correction, and the surrounding context; reasons about what the agent did versus what it should have done; drafts a structured update to the catalog, such as a definition, join rule, or caveat; and, after a human certifies it, writes that knowledge back permanently.
The forty-two-dollar rule, learned once from a single wrong answer, becomes catalog knowledge every future agent inherits. In a twenty-table pilot, the loop generated roughly a hundred such notes and increased the agent’s SQL accuracy by a claimed sixty-three percent.
That is a real answer to the objection that automation only structures what is already legible.
It manufactures new context from failure.
But read the loop closely and it confirms the deeper limits rather than eliminating them.
Someone still eats the first wrong answer. The system learns the missing rule only after an agent has already returned a bad revenue number to someone who trusted it.
A human still certifies every update. The authority problem has not been automated away. It has been formalized into a review step, which is the honest place for it to live and also the point where the “fully agentic” story quietly ends.
And the correction remains fragile until it is written back. In the demo, a fee change lived only inside one session and reverted the moment a new session began.
Context, in this architecture, is not a thing you have. It is a thing you must keep manufacturing, forever, against a corpus that keeps changing underneath you.
The Open Format
Two months after the rebrand, in June 2026, Google published the Open Knowledge Format, a deliberately minimal, vendor-neutral specification for agent-readable knowledge.
A bundle is a directory of Markdown files with YAML frontmatter, one concept per file, linked by ordinary Markdown links that form a graph. One required field. No SDK, no runtime, no proprietary API. It ships in Git, renders on GitHub, and can be read by any agent.
Knowledge Catalog ingests the format natively, while the catalog itself is repeatedly positioned as an open ecosystem without vendor lock-in, including bidirectional metadata exchange with rival catalogs it also crawls.
Taken at face value, this cuts against everything above. A company trying to own the semantic layer is publishing an open format that makes semantic knowledge portable while boasting about interoperability with its competitors.
It is not a contradiction.
It is the 2011 move repeated.
Google seeded schema.org so publishers would structure their own pages in a vocabulary Google’s crawler could read. It was a genuine open standard that also happened to industrialize the supply of structured input to Google’s index.
The same mechanism applies here.
An open format is a solvent applied to everyone else’s lock-in, and a funnel into your own ingestion.
Enterprise knowledge currently sits trapped inside rival catalogs, proprietary APIs, semantic layers, documents, and databases. A portable format and bidirectional connectors dissolve part of that trap.
But once the knowledge is portable, where does it go?
The most convenient destination is likely to be the catalog whose vendor wrote the specification, built the reference tooling, and integrated the consumer. The reference implementation makes the gravity clear: the producer agent runs on Gemini, the demonstrated source is BigQuery, and the obvious consumer is Knowledge Catalog.
The license is neutral. The ecosystem is not.
This is also some of the strongest evidence that Google is playing for the layer rather than the services line.
You do not publish an open standard for a consulting practice.
You publish one for a substrate you intend to sit under.
Is the Motion Actually Different?
Here the marketing and the substance need to be separated, because Google is not abstaining from the human motion. Google Cloud plans to hire hundreds of forward-deployed engineers of its own.
Everyone in this race runs both plays.
The difference is not humans versus no humans.
The difference is what each competitor treats as the durable motion.
For Palantir and the labs, the human FDE is part of the product. High-touch deployment is where value is delivered, and last-mile judgment is precisely where the margin is defended. Amazon has similarly built a billion-dollar forward-deployed engineering practice as a capture apparatus, not merely a temporary bridge.
For Google, the human FDE is explicitly the thing the system should eventually automate away.
And the reason matters:
Google is the only competitor whose core historical competency is exactly web-scale automated structuring. The others are learning to automate the forward-deployed engineer. Google is redeploying the machine that automated the web.
There is also a business-model difference underneath the labor one.
A services motion bills hours and does not compound. A catalog motion converts that work into metered infrastructure that runs continuously and becomes cheaper per unit as coverage grows.
The consultant becomes a subscription.
That is the conversion Google is attempting, and it is why the automation claim matters more than the headcount claim.
Two cautions keep this honest. First, the claim that the motion is genuinely different remains, for now, a positioning claim. The proof is still a roadmap, and the $42 loop shows that the current architecture depends on both a human certifier and a first wrong answer.
Second, running both motions simultaneously is a hedge, not a pure bet.
That hedge is the most Google thing in the story. The same instinct appears elsewhere in its stack: cover the outcome rather than commit to one path.
Where It Breaks
The mechanism is specific enough to fail in specific ways, and the failure modes are not marginal.
The Signal Only Structures Data That Gets Touched
Relationship inference runs on schemas and query logs. Cold tables have no usage, net-new data has no history, and the knowledge-gap loop learns only where an agent has already fallen.
The mechanism is therefore strongest exactly where the forward-deployed engineer was least needed, on tables people already use well, and weakest where structuring matters most.
The self-describing-corpus problem the web solved for free does not disappear inside the firewall. It relocates to the untouched majority, and gets filled one wrong answer at a time.
Usage Is Not Authority
The $42 problem is the general case.
Which definition is correct may be a governance fact, a contractual fact, or an organizational decision about whose rule wins. It is not simply a statistical regularity waiting to be mined from behavior.
Automation can surface candidates, identify contradictions, and learn from failures. Someone with standing still has to ratify the result.
The human certifier in the loop is therefore not obviously temporary scaffolding.
It is where authority actually lives, and where “fully agentic” stops being true.
The Evaluation Loop Is Closed
Google builds the semantic layer. Its agents query that layer. The gap agent evaluates the query agent. The same vendor’s model sits on both sides.
That vertical integration is the pitched advantage, but it also means the system can certify its own consistency without independently establishing whether the inferred relationships are actually correct.
In a domain where a wrong join misstates revenue:
Self-consistency is not correctness.
Error Economics Are Inverted
A wrong search result costs a scroll. The web tolerated a bad result at position two because the human reading it remained the final filter.
A wrong context relationship can misroute a payment or misstate a number to management, while the design goal is increasingly to remove the human who would have caught the mistake.
Tolerance for hallucinated structure therefore runs from generous on the open web to near zero in the ledger, while the mechanism producing the structure remains probabilistic in both.
Permissioning Is a Different Architecture
Access is inherited from source systems, which is the right design. But that also caps the catalog’s usefulness at the coherence of the permission model underneath it.
Most enterprises do not have a coherent one.
The catalog inherits that mess along with the data.
Freshness Is a Treadmill
The demo contains its own tell: a corrected number lived inside a single session and reverted when the session ended.
Context has to be continuously re-manufactured as schemas, definitions, contracts, teams, and business rules drift.
The catalog is never finished.
What looks like a one-time structuring exercise becomes a permanent operating system for maintaining meaning.
Clear Title Is the Buyer’s Problem
The more completely a vendor structures your data, and eventually your institutional knowledge once the gap agent begins extracting it, into its catalog, the higher the cost of leaving.
The automated forward-deployed engineer is the industrialized version of precisely the dependency an enterprise should be auditing.
The open format is a partial answer. A portable bundle is genuinely portable. But the format standardizes packaging, not semantics. The graph, the golden queries, the accumulated corrections, and the serving layer remain where they were built.
How It Cascades
Place this in the stack and it stops being a Google story.
It is the fourth instance of the season’s defining pattern, and the deepest.
The map already holds three cases where value is captured not by owning the agent itself but by owning the junction a rented agent must pass through: Palantir at the enterprise junction, Shopify at the settlement rail, and Figma at the creation substrate.
Knowledge Catalog is the fourth:
Agents get rented. The semantic layer gets owned.
And it may be the most fundamental because the context substrate sits beneath the other three. The reconciled meaning of an enterprise’s data is an input that a junction, a rail, and a creation surface all need to query.
Google says this explicitly about its own stack: every agent it builds hits the catalog for context first.
Own that layer and you own what the other captors depend on.
The Junction Beneath the Junctions
The established reading was that models get rented and the routing fabric gets owned.
Google’s move pushes the thesis one layer lower.
A router without reconciled context routes blind. If that is true, the router is not the floor of the moat. The context layer underneath it is.
That changes Google’s strategic placement. Until now, Google could be understood largely as owning volume and visibility inside other firms’ junctions, often as the inexpensive model or infrastructure provider.
Knowledge Catalog is Google trying to stop renting into junctions and start owning the one beneath all of them.
The Demand-Side Twin of the Inference Bet
The supply-side story explained why Google increasingly tunes its infrastructure toward inference: inference is the recurring product workload with an external buyer, the one that meters continuously.
Industrialized context-serving to millions of enterprise agents is exactly that workload. Google’s own framing is that agents will come and go by the thousand, each demanding fresh context at guaranteed latency.
The two strategies lock together.
Google is betting that the money is in owning and serving structured enterprise context at inference scale rather than merely winning the frontier-model race.
The context play also deepens the absorber paradox. Owning the model, the data cloud, the context engine, and increasingly the customer’s semantic layer lets Google capture value across the stack while conceding the top of it.
The Buyer-Side Collision
The automated forward-deployed engineer is the absorption machine at industrial scale, the supply-side engine that dependency auditing exists to resist.
The map now carries a matched pair: a supply-side node building the capture machine and a buyer-side test asking whether, after the engagement ends, the enterprise still holds clear title to what compounds.
Automating capture, and now automating the extraction of institutional knowledge that previously lived in employees’ heads, makes the mechanism cheaper to run at scale.
That sharpens the buyer’s problem rather than softening it.
Pressure on the Other Return-Side Nodes
If Google succeeds in automating toward the last mile, it leans directly on Palantir’s value-capture pole, whose economics depend partly on the human mile being compressed.
It also challenges the labs’ FDE-as-product motion, which remains comparatively labor-linear and does not compound in the same way.
The efficiency clock points in the same direction: as models commoditize, the value of the owned context junction rises.
Google is racing to be the one holding it.
Against the four clocks, the position is a straddle no other name occupies. Google is simultaneously a floor node, a supply-side node, and now a bid for the deepest value-capture node. The capex financing the bid is its own.
The absorber thesis was always a bet on the structure itself. This extends it into a bet on owning the substrate the structure runs on.
The Fault Line
One question remains unsettled on the cost curve, and it decides who wins.
If the semantic layer is the prize, the buyer’s interest and the platform’s interest point in opposite directions.
The enterprise wants that layer portable and vendor-neutral: an asset it controls, that any model can query, and that does not wire the company to a single supplier.
The platform wants the same layer captive, tuned to its own model, and load-bearing enough that leaving means rebuilding.
Google owning both the model and the layer that decides what the model sees is powerful for exactly the reason it is contestable.
It is the control point.
The open format is Google’s answer to that objection, and it is a real one, arguably more substantive than what most rivals have offered.
It is also precisely the answer schema.org was:
Give away the format. Keep the index.
Whether that becomes generosity or gravity depends on something not yet determined: whether producers outside Google adopt the standard, whether competing systems become first-class consumers, and whether the format eventually governs semantics rather than merely packaging.
So the real question is not whether Google can automate the forward-deployed engineer.
On its record, assume it eventually can.
The question is whether enterprises will let the company that monetizes context also own theirs, the same bargain the open web struck and later regretted, now offered one layer closer to the balance sheet.
Mental Models
The Second Index. The competency that wins a corpus is the industrialization of its structuring, not merely the intelligence applied on top. Search was won by the index, not merely the ranking; enterprise AI is being contested around the semantic layer, not merely the model. Whoever automates the structuring of a chaotic corpus owns the economics of everything queried against it.
The Directory Editor Problem. Any human-curated catalog loses to an automated one once the corpus grows faster than curators can be hired. The forward-deployed engineer is the enterprise’s directory editor: high-judgment, high-cost, linear, and betting the exponent stays small enough to hand-cover.
Usage Is the Substitute Signal. Where a corpus does not describe itself, structuring machines fall back on behavior. The web offered links and clicks; the enterprise offers query logs. The substitution is ingenious and load-bearing, but it inherits every bias in what people happen to do and misses what they never record.
The Cold Corpus. Any usage-derived signal reaches only data already in use. Coverage is highest where the manual alternative was cheapest and thinnest where structuring was most needed. Automated structuring does not eliminate cold start. It concentrates it.
Usage Is Not Authority. Logs reveal what an organization does, never what it should do. Contested definitions are governance facts requiring ratification, not regularities awaiting extraction. The $42 rule is the proof: no amount of usage reveals a charge that lives only in a contract and a departed employee’s memory.
Context Is Learned From Loss. When missing knowledge exists in no usable system, one way to acquire it is through failure that forces someone to supply the missing rule. A failure-driven catalog is genuinely powerful and structurally reactive: it fills each gap only after an agent has already fallen into it, and someone always eats the first wrong answer.
The Certifier Remains. Automating the discovery of context does not automate authority over it. The human who ratifies a definition is not merely temporary scaffolding. That review step is where “fully agentic” quietly ends, and where it probably should.
The Golden Query Is the Unit of Capture. Descriptions are labels; encoded business logic is the asset. The moment a firm’s verified computation of a metric lives in a vendor’s catalog instead of an engineer’s head, exit cost stops being a data migration and becomes a reconstruction problem.
The Closed Evaluation Loop. When one vendor supplies the context, the agent, and the grader, the system can certify its own consistency. Self-consistency is not correctness, and the gap between them can be invisible from inside the loop.
The Open Format as Solvent. Publishing an open standard for a layer you intend to own is not a contradiction. It dissolves rivals’ lock-in, industrializes the supply of structured input, and leaves ecosystem gravity with whoever wrote the specification and built the most convenient consumer. The license can be neutral while the funnel is not.
The Consultant Becomes a Subscription. The strategic content of automating a services motion is the conversion of billed hours into metered infrastructure. Read a vendor automating its own deployment labor as an attempt to change what the business is, not merely what the business costs.
The Junction Beneath the Junctions. Value-capture layers stack. A routing fabric routes against context; a settlement rail and a creation substrate depend on it too. The deepest ownable position in an agentic stack may be the reconciled meaning of the customer’s own data.
Structuring Is Ownership. Whoever builds the graph increasingly holds the graph. Automating its construction is not primarily a cost decision. It is the mechanism by which the builder can occupy the semantic layer faster than a competitor paying humans by the hour. Software scales; headcount does not.
With massive ♥️ Gennaro Cuofano, The Business Engineer