Glean
Glean builds “Work AI” — one permissioned index over a company’s apps that powers “intelligent Search, an AI Assistant, and scalable AI agents” across “100+ enterprise SaaS connectors” (Backend JD). Ask in natural language; Glean retrieves the right document, person, or action — filtered to what you are allowed to see — and increasingly acts, not just answers. This is a mature, late-stage build, and that’s the interesting part: the engineering story is how a search engine hardens into enterprise infrastructure — a permissioned knowledge graph, hybrid retrieval, single-tenant isolation, multi-provider model routing, and an eval-gated agent runtime.
Vitals: founded 2019 · Series F ($150M @ $7.2B; ~$768M raised) · ~1,600 people · global (HQ + India).
Business context — founders, funding, scale
- Founded 2019 by Arvind Jain (a Distinguished Engineer on Google Search who went on to co-found Rubrik) with three other ex-Google engineers — Vishwanath T R, Tony Gentilcore, Piyush Prahladka (Fortune). The DNA is Google web search, retargeted at the messy, permission-bounded corpus inside a single company.
- Series F: $150M at a $7.2B valuation, led by Wellington Management (June 10 2025, press release); ~$768M raised total, headcount near ~1,600 (Sacra).
- “Glean rapidly surpassed $100 million in annual recurring revenue (ARR) in its last fiscal year” (press release).
- “The platform is already powering more than 100 million agent actions annually,” with a stated goal of “one billion agent actions by the end of the year” (press release).
The heavy lifting
Section titled “The heavy lifting”- A permissioned knowledge graph, not just a vector store. A triplet store carries ACLs, timestamps, and provenance on the edges, enabling multi-hop, access-faithful retrieval; the index — not the model — is the asset (LLMs are multi-provider, routed, zero-retention) (knowledge graph, Runtime JD).
- Permission enforcement is the retrieval invariant. Connectors map and maintain each source’s ACLs so a query never returns a document the user can’t open — the enterprise-search bottleneck is access fidelity, not recall (Data flow, Security).
- Single-tenant inside the customer’s own cloud. Ingestion, index, and knowledge graph run in the customer’s GCP/AWS/Azure project via Dataflow pipelines; “data never leaves your tenant’s environment” — a full per-tenant deployment traded for enterprise data residency (Data flow, Security).
A Go-leaning backend, a Bazel monorepo, Kubernetes on a major cloud, and a deliberately model-neutral AI layer. Every row is named in a first-party JD, doc, or repo.
| Layer | Choice | Evidence |
|---|---|---|
| Backend languages | Go (preferred), Python, Java, C++ | Runtime JD, Context JD, Backend JD |
| Client / SDK languages | TypeScript, Python, TypeScript, Java, Go SDKs | Dev platform, Context JD |
| Build system | Bazel monorepo — custom rules/macros, remote execution | Dev Productivity JD |
| CI/CD | GitHub Actions on Kubernetes + cloud runners | Dev Productivity JD |
| Containers / orchestration | Docker · Kubernetes | Dev Productivity JD, Runtime JD |
| Cloud | GCP / AWS / Azure (single-tenant, in customer’s cloud) | Security, Runtime JD |
| Ingestion | Google Dataflow pipelines | Data flow |
| Event / streaming | Pub/Sub, Kafka | Runtime JD |
| Caching | Redis + low-latency data stores | Runtime JD |
| Observability | OpenTelemetry tracing, metrics, dashboards | Runtime JD |
| LLM providers | OpenAI · Anthropic · Google Gemini + model routing | Runtime JD |
| Agent interop | MCP — single HTTP endpoint into 20+ hosts | Dev platform |
| Agent frameworks | LangChain, OpenAI Agents SDK, Google ADK, CrewAI | Dev platform, Toolkit repo |
| Internal coding AI | GitHub Copilot, Cursor, Claude | Dev Productivity JD |
Hard problems
Section titled “Hard problems”The parts an engineer would lose sleep over. Public signal is cited (verified); likely approach is labeled speculation — best-practice fill-in, hedged.
| Problem | Why it’s hard | Public signal | Likely approach (speculative) |
|---|---|---|---|
| Testing agents | Non-deterministic, no shared ground truth; per-tenant isolation means customer queries can’t be pooled into one eval set | +24% relevance benchmark; runtime self-reflects on “its own confidence”; Runtime owns “safety” (agentic, Runtime JD) | Offline golden-set + LLM-as-judge on synthetic corpora; online confidence-gating and per-tenant A/B |
| Inference cost | Multi-step plans multiply LLM calls against a ~10× action ramp (100M→1B/yr) | “model selection/routing” + multi-provider; Redis cache; RAG “minimizes LLM data exposure” (Runtime JD, Security, press) | Tiered routing (small classifier gates frontier calls); semantic caching of repeated queries; cap plan depth/fan-out |
| Observability | Reproducing why spans a rewritten plan, sub-agents, and many tool calls; isolation limits what Glean can inspect | ”tracing (OpenTelemetry), metrics, dashboards, and production forensics” (Runtime JD) | One trace per run, a span per step/tool; retain reasoning traces + confidence per tenant; aggregates leave, raw data doesn’t |
Likely internals
Section titled “Likely internals”The retrieval engine, models, and stores Glean describes but doesn’t name — inferred from the public record (an ex-Google-Search team would build, not buy):
| Component | Likely choice | Basis |
|---|---|---|
| Index / retrieval engine | a proprietary inverted index + embedding store, not a named third-party vector DB | ”anchors and signals,” “self-learning language model” (hybrid search); no vendor named; ex-Google-Search team would build |
| Embedding models | fine-tuned in-house embeddings alongside provider embeddings | hybrid/self-learning search (hybrid search) + multi-provider posture (Runtime JD) |
| Knowledge-graph store | a graph materialized over the tenant index rather than a standalone graph DB | triplets + edge properties derived from indexed content (knowledge graph); no graph DB named |
| Ranking model | learning-to-rank over the anchor/signal features | ”self-learning language model” + the explicit signal list (hybrid search) |
| Memory store | per-tenant store keyed to the knowledge graph | ”memory” is a named runtime + platform primitive (Runtime JD, Context JD); backing store unstated |
| Permission enforcement | both index-time ACL filtering and request-time checks | ACLs are mapped and enforced (Data flow, Security); index-time vs. request-time timing isn’t specified |
| Auth | enterprise SSO (SAML / OIDC) | SSO is confirmed at the query boundary (Data flow); IdP breadth not enumerated |
Architecture
Section titled “Architecture”Retrieval is the substrate; agents sit on top
Section titled “Retrieval is the substrate; agents sit on top”Glean’s core is a hybrid search engine: “the precision of lexical search and the nuanced understanding of vector search—all powered by the additional context and nuance provided by the signals and anchors within our knowledge graph” (hybrid search). Ranking is driven by “countless anchors and signals” — “normalization … synonymy … intent classification … document understanding … popularity” and personalization (hybrid search).
The knowledge graph is the moat. It’s a triplet store — “at the core of a knowledge graph is the triplet structure: (subject, predicate, object)” — where “edge properties—such as timestamps, access control, confidence scores, or provenance—can be attached to each relationship” (knowledge graph). It’s built automatically (“automated noun extraction,” “frequency and prominence filtering,” signals like “presence in the titles of key documents”), plus a personal graph that “captures employee activity,” clustering “each atomic action into subtasks” then “higher-level tasks.” Glean’s name for the whole thing: “the system of context.”
On top, agentic reasoning: “agents decompose questions into multi-step plans. Each step is executed by agents using tools, such as search, reasoning, data analysis, employee search, and expert search” (agentic reasoning). The plan phase “run[s] a series of initial questions to the LLM to gather background information” then “rewrite[s] the query into a multi-step plan”; sub-agents “reason about the tools to use” and the system “self-reflect[s]” on “its own confidence in its answer.” Crucially: “the basis for many tools in Glean is search.” The claimed payoff is “a significant increase of 24% in the relevance of responses and actions.”
Mermaid source
flowchart LR classDef src fill:#eef2f8,stroke:#94a3b8,stroke-width:1.5px,color:#0f172a; classDef data fill:#e8f1fd,stroke:#2563eb,stroke-width:1.5px,color:#0f172a; classDef kg fill:#eef0fe,stroke:#6366f1,stroke-width:1.5px,color:#0f172a; classDef agent fill:#eafbf1,stroke:#16a34a,stroke-width:1.5px,color:#0f172a; classDef io fill:#fdf4e8,stroke:#d97706,stroke-width:1.5px,color:#0f172a;
Q(["User / agent question"]):::io
subgraph Plan["Plan"] direction TB LLM0("LLM gathers background<br/>+ rewrites into a multi-step plan"):::agent end
subgraph Exec["Execute · sub-agents pick tools"] direction TB T1("hybrid search"):::agent T2("data analysis"):::agent T3("employee / expert search"):::agent T4("email · calendar · code"):::agent end
subgraph Retr["Hybrid retrieval · 'the basis for many tools is search'"] direction TB Vec("vector search<br/>semantic"):::data Lex("lexical search<br/>keyword precision"):::data Sig("anchors & signals<br/>intent · popularity · personalization"):::data end
KG[("Knowledge graph<br/>triplets (subject,predicate,object)<br/>+ personal graph · edge ACLs")]:::kg
Reflect("Self-reflection<br/>assess confidence in answer"):::agent Ans(["Grounded answer / action"]):::io
Q --> Plan --> Exec T1 --> Retr Vec --- Lex --- Sig Retr --> KG KG --> Reflect T2 --> Reflect T3 --> Reflect T4 --> Reflect Reflect --> AnsThe runtime that hosts this is owned by the Agents Runtime team — “the low-latency, reliable, and secure foundation that powers Glean’s AI agents and assistant experiences at scale,” providing “core runtime services for multi-turn orchestration, tool calling, model routing, memory, streaming, and safety” (Runtime JD). The Context Platform team exposes it outward — SDKs, “agent SDKs and integrations, MCP servers,” and platform actions “such as Code Search, Code Writer, and Memory” built as “reusable platform primitives on top of Glean’s horizontal layers (connectors, security/governance, knowledge graph, memory, model orchestration)” (Context JD).
Deployment: a search engine that runs inside your cloud
Section titled “Deployment: a search engine that runs inside your cloud”The architectural bet that separates Glean from a generic RAG SaaS: each customer gets “a fully isolated, single-tenant environment,” “either Glean-hosted or in your own AWS, Azure, or GCP cloud” (Security). Ingestion and indexing happen in the customer’s project — “all data processing occurs within your tenant’s project using Google Dataflow pipelines. Your data never leaves your tenant’s environment” (Data flow). Queries hit a tenant-specific endpoint, “<tenant_id>-be.glean.com,” after SSO auth, and model calls run under “zero-retention agreements with model providers” (Data flow, Security).
Mermaid source
flowchart LR classDef src fill:#eef2f8,stroke:#94a3b8,stroke-width:1.5px,color:#0f172a; classDef data fill:#e8f1fd,stroke:#2563eb,stroke-width:1.5px,color:#0f172a; classDef kg fill:#eef0fe,stroke:#6366f1,stroke-width:1.5px,color:#0f172a; classDef ext fill:#fdecec,stroke:#e0564f,stroke-width:1.5px,color:#0f172a; classDef io fill:#fdf4e8,stroke:#d97706,stroke-width:1.5px,color:#0f172a;
subgraph Sources["Customer data sources"] direction TB SaaS("100+ SaaS connectors<br/>(over HTTPS)"):::src OnPrem("On-prem sources<br/>(VPN / Shared VPC)"):::src end
subgraph Tenant["Single-tenant project · customer's own GCP / AWS / Azure (or Glean-hosted)"] direction TB Ingest("Google Dataflow pipelines<br/>crawl · extract · permission mapping"):::data Index[("Tenant index + knowledge graph<br/>data never leaves the tenant")]:::kg QE("Query endpoint<br/><tenant_id>-be.glean.com"):::data Ingest --> Index --> QE end
User(["Employee / agent<br/>SSO-authenticated"]):::io LLM("LLM providers<br/>OpenAI · Anthropic · Gemini<br/>zero-retention"):::ext
SaaS --> Ingest OnPrem --> Ingest User -->|"search · chat · agents API"| QE QE -. "RAG context, permission-filtered" .-> LLM LLM -. "grounded answer" .-> QETeam & process
Section titled “Team & process”Founder-led by ex-Google search engineers; ~1,600 people (Sacra), organized by horizontal platform layer rather than product vertical.
| Role | Person | Source |
|---|---|---|
| Co-founder / CEO | Arvind Jain (ex-Google Search; Rubrik co-founder) | Fortune |
| Co-founders | Vishwanath T R, Tony Gentilcore, Piyush Prahladka (ex-Google) | Fortune |
The team shape, from the JDs: Agents Runtime (orchestration, routing, memory, streaming, safety — Runtime JD); Context Platform (SDKs, MCP, Code Search/Writer, Memory — Context JD); Backend/Infrastructure (“a highly performant, scalable, secure, permissions-aware system,” “6+ years … distributed systems” — Backend JD); and a dedicated Developer Productivity org owning the Bazel monorepo and remote-execution CI (Dev Productivity JD). Engineering is global, with a “Software Engineer, Product Backend (India)” track (Careers); posted backend/dev-productivity comp runs roughly $140K–$265K base (Dev Productivity JD).
The dev loop is Google muscle-memory at startup speed — Bazel monorepo, remote-execution CI, GitHub Actions on Kubernetes — and AI-native by mandate: the same Dev Productivity org wires “Github Copilot, Cursor, Claude” into daily workflows, and interviews include “an AI-focused exercise or discussion” (Dev Productivity JD, Runtime JD). A company selling an enterprise assistant and wiring coding assistants into its own monorepo almost certainly runs Glean on its own corpus — the coding-assistant half is explicit; internal product use is the obvious unstated other half (inferred, confidence: medium).
Sources
Section titled “Sources”Reconstructed from public sources only — no insider information. Crawled 2026-06-08 (web search + page fetch; Chrome MCP browsing was declined this session, so no login-walled JDs). Claim tiers: verified (stated on a public page, linked) · inferred (reasoned from a cited signal, confidence flagged) · speculative (best-practice fill-in, labeled). Links are live; pages change, so the supporting quote for each claim is kept in this repo’s evidence map (evidence/glean-evidence-map.md).