# Pinecone 2.0 — Edo Liberty, Pinecone

Edo Liberty, Pinecone

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/IN-rb-9WmiY-pinecone-2-0) · [Video](https://www.youtube.com/watch?v=IN-rb-9WmiY)

## Pinecone 2.0

Edo Liberty explains how a persistent knowledge layer can maintain company context, accept questions with a budget, and write and run code while answering.

![Selected presentation frame from Pinecone 2.0 — Edo Liberty, Pinecone at 467 seconds](https://ai.engineer/api/talk-essay-media/35b9ae781306d5ffd02cf0208d4104c8a3d2c1b7b9756bac6a2c3ccd1dea15f2)

Pinecone’s Nexus: giving agents company knowledge that survives the session

### What does your agent actually know?

[0:13](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=13s)

People asked Yahoo Answers whether they were fat. The forum had no personal information with which to answer, but the question still arrived. [Edo Liberty](https://edoliberty.com/), who worked at Yahoo roughly fifteen or sixteen years before this talk, uses that example to introduce theory of mind: our ability to model what someone else knows, believes, and might do. A user also needs a working model of what a product knows. Liberty argues that enterprise agents invite a subtler version of the same mistake: their fluency and general competence make it easy to assume they understand the company around them.

### Three kinds of knowledge

Liberty offers a broad taxonomy, rather than an exhaustive account of knowledge:

- **General knowledge:** Public information absorbed during model training. His examples include improving Rust code, explaining legal terminology, and exploring product use cases. These are capabilities an agent can bring to a task before learning anything about its employer.
- **Specific knowledge:** Private facts such as what the company’s codebase implements or what a particular customer’s contract contains. Retrieval-augmented generation (RAG), search, and vector databases give agents access to this material. Liberty treats these as established approaches while acknowledging that there is still work to do.
- **Tribal knowledge:** The understanding a seasoned employee has about processes, ownership, guiding principles, and how work gets done. It belongs to the company, but a search result from one document may not capture it.

![Selected presentation frame from Pinecone 2.0 — Edo Liberty, Pinecone at 216 seconds](https://ai.engineer/api/talk-essay-media/6355ee5534116e46783bb44fd637b7205852edc1e6b63e7224238f39dded8ca8)

What does your agent actually know?

The third category creates the gap Liberty wants to address. Finding a culture document does not necessarily teach an agent how the organization operates. That understanding comes from many pieces of information considered together. An agent may retrieve relevant passages and still lack the accumulated sense of which goals, priorities, and processes should govern its work.

His model for the enterprise agent is a brilliant new hire: capable, equipped with tools, and facing high expectations, but unfamiliar with the company. It must read documents to orient itself. When most sessions begin from scratch, the agent repeatedly returns to its first day on the job. The missing capability is the ability to carry company understanding forward into the next task.

### Preserve understanding—and know when it becomes obsolete

[4:47](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=287s)

Liberty proposes a shared knowledge layer with three requirements:

- **Persistence:** Building company understanding takes substantial effort. The accumulated work should remain available to all the company’s agents, rather than be reconstructed for every session.
- **Specialization:** HR practices, kernel optimization, and customer support require different information. Liberty recommends that domain experts own the relevant knowledge and interact with it to keep it aligned with company goals.
- **Freshness:** Companies change. The layer must keep current information useful and deprecate information that no longer applies.

### The CEO example: new facts must outweigh old references

Freshness is the hardest requirement. Suppose a company replaces its CEO. By the next day, employees know who leads the company, even if nine thousand documents spanning the preceding ten years still name the former CEO. The new fact overrides those historical references. An agent that simply retrieves old documents can confidently arrive at the wrong present-day answer.

This makes freshness a problem of changing the stored understanding, as well as bringing in new material. Adding another document does not by itself establish which fact now applies. Liberty’s requirement is that a knowledge layer recognize the change and stop treating obsolete information as current.

The layer sits alongside the agent’s existing capabilities. LLMs, tools, local files, RAG, vector search, and text search remain useful. Liberty wants a separate entity that many agents can consult for company understanding while continuing to use their own tools. Shared knowledge can persist even as individual task sessions begin and end.

![Selected presentation frame from Pinecone 2.0 — Edo Liberty, Pinecone at 451 seconds](https://ai.engineer/api/talk-essay-media/731dd858f4a2e70187b505e24ac3b4bd6c4449ef7cc5df8cdd55e1a9748ad0c8)

Persistent, specialized, and current

### A manifest tells Nexus what to remember

[7:40](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=460s)

**Nexus** is Pinecone’s implementation of the knowledge layer. Liberty introduces four parts: connectors, context, tasks, and queries. Connectors bring data into the platform while respecting access rights and controls. He moves through them quickly, but stresses that enterprise ingestion and permissions are painstaking to get right. They determine which information enters the system and under what access restrictions.

A context is the collection of assets Nexus maintains for a topic such as HR, operations, or engineering. It includes source connections and a manifest. The manifest specifies the tasks to support, the entities to track, and the information worth remembering. Liberty contrasts this with manually writing and maintaining skills, plugins, commands, and Markdown context files. The owner describes what matters; Nexus organizes and maintains the resulting knowledge.

### Five representations with different jobs

The manifest describes the interests of the context. The knowledge assets hold and organize what the system has learned:

- **Semantic map:** A catalog of where information lives, including key schemas and glossaries. It gives the system a way to navigate the context.
- **Markdown files:** Unstructured information, decisions, memories, and notes. Liberty compares this to LLM Wiki, an idea he attributes to Andrej Karpathy in which agents manage Markdown files to keep their own notes.
- **SQL tables:** Tabular facts and data that support aggregation.
- **Vector database:** Information available through semantic search, text search, and filtering.
- **Graph entities and indexes:** Entities, relationships, and causal chains.

![Selected presentation frame from Pinecone 2.0 — Edo Liberty, Pinecone at 614 seconds](https://ai.engineer/api/talk-essay-media/44f7f28e48157d217027d53e8dd0b02fa9914b385e79f27279e31a0f5bd22a83)

A manifest tells Nexus what to remember

These representations let the context retain more than prose notes. Tables can support calculations over facts; search can locate relevant material; graphs can retain relationships. The semantic map describes how to find and use the assets. Liberty says Nexus creates and manages them through the manifest, so users do not need to build each table, index, or graph themselves. The manifest becomes the main way to direct what this managed system should keep.

### Curation turns incoming material into maintained knowledge

[11:45](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=705s)

Having described the stored objects, Liberty turns to the actions that change them. Import brings in new files, events, and concepts. Curation incorporates their information into the context’s existing understanding. His examples are a new PDF, meeting transcript, or board presentation. The important step happens after the material arrives: the system must work out what this context should remember and what needs to change.

The curator takes three inputs with different roles. The new material supplies information. The manifest identifies the concepts and entities that matter. The semantic map tells the curator where the relevant knowledge is stored. Together, they guide updates to tables, graph relationships, text indexes, and other assets. When curation finishes, the assimilated information persists in the context.

This is where the earlier CEO example belongs in the architecture. A new announcement can lead to changes in maintained knowledge, rather than merely become one more searchable document. However, Liberty does not specify how the curator decides that one source supersedes another or how it handles contradictory claims. The update path is explained; the reliability of those judgments remains open.

Search then exposes simple internal functions for accessing the context. The answering agent does not have to learn the access details of every table, graph, or index. This keeps the two jobs separate: curation maintains several knowledge representations, and a compact set of functions makes their information available to the querying engine.

How a meeting transcript changes a context
Curation uses the manifest to decide what matters and the semantic map to locate the assets that need updating.
- New meeting transcript — Imported material supplies new information.
- Manifest — Specifies concepts, entities, and information to remember.
- Semantic map — Describes where existing information is organized.
- Curate — Determines which stored representations need changes.
- Updated context — Changes to tables, graph relationships, and text indexes persist.
- New meeting transcript → Curate (Information to assimilate)
- Manifest → Curate (What matters)
- Semantic map → Curate (Where to update)
- Curate → Updated context (Update and persist)

### NoQL gives the question a budget

[13:32](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=812s)

**NoQL** specifies how an agent wants information out of a context. Liberty argues that a question alone does not communicate enough. The calling agent should also describe the resources the answer deserves: a budget in tokens or dollars, and how much time to invest. A quick answer and a thorough investigation can begin with the same question while requiring very different amounts of work.

The caller chooses between immediacy and a more extensive search in pursuit of accuracy. Nexus returns grounded text structured for another agent to use. This makes NoQL an interface between agentic systems, with effort and output requirements that go beyond conversational wording. Liberty does not provide a request schema or explain how budgets are enforced; additional effort is an intended control, not a demonstrated guarantee of correctness.

### The answering engine writes and runs code at query time

[14:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=886s)

Liberty next opens up the answering engine. He describes a Nexus interface with a question at the top, steps on the left, and generated code at the bottom right. The code illustrates what he calls a runtime coding agent. In the conventional coding-assistant workflow he contrasts it with, the model edits software that is later deployed; the deployed artifact can run without the model. In Nexus, the model participates while the question is being answered.

### Write, execute, inspect, revise

The engine works like a Jupyter Notebook or Python REPL. It writes code and executes it, then uses the result to decide what to do next. If the result differs from what it expected, it rewrites that piece of code and runs again. The answer emerges from an executable procedure developed during the request. The system can use code to obtain the information needed for the task, rather than express the entire task as one database query.

The resulting code can be saved and rerun. That gives a completed request a reusable artifact as well as an answer. The flexibility comes from combining executable logic with access to the context’s stored representations through its internal functions. The loop can adapt to unexpected results, but Liberty does not explain how the agent establishes that its answer is correct or how it chooses a stopping point.

### A smaller description of the available interfaces

Liberty reports a reduction from roughly 150,000 tokens of tooling instructions to fewer than 1,000 tokens describing the interfaces needed to get information out of Nexus. This quantity concerns the prompt used to describe access to the tooling. It is not the total token cost of answering a question: the runtime agent still generates code and may iterate. The smaller interface lets agents reach managed knowledge without carrying the same large inventory of tool descriptions.

The query-time coding loop
The model remains involved during execution, revising code when results differ from expectations.
- Agent question — Starts a Nexus answering task.
- Write code — Build an executable procedure at query time.
- Execute code — Run the generated code in a notebook-like environment.
- Inspect result — Determine whether the result matches expectations.
- Complete the task — Obtain the requested information; code can be saved and rerun.
- Agent question → Write code (Answer at query time)
- Write code → Execute code (Run)
- Execute code → Inspect result (Observe result)
- Inspect result → Write code (Unexpected result: revise)
- Inspect result → Complete the task (Requested information obtained)

### Prepared context changes the comparison

[17:32](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1052s)

The closing comparison gives the same task to Nexus through NoQL and to an agent with the tools to complete it independently. Liberty returns to the new-hire analogy: the independent agent must read documents, find the data, understand the task, and write code. He reports that this route is slower, uses more tokens, and is less accurate because it lacks the maintained company context and objectives.

The comparison combines persistent preparation with the answering engine. Both routes can involve writing code, but one begins with accumulated company knowledge and an interface for using it. It therefore does not isolate runtime code generation as the sole cause of the improvement. It illustrates the work an agent can avoid repeating when the organization has already been interpreted and organized for it.

### Reported early-access outcomes

Liberty describes gains across early-access customers, domains, and tasks:

- **Token consumption:** He cites reductions of 77% and 90% as common examples.
- **Speed:** He describes systems becoming 20% or 30% faster, and sometimes 77% faster.
- **Accuracy:** He claims that answers also become more accurate, treating this as the most important gain, but supplies no numerical accuracy measure in his explanation.

![Selected presentation frame from Pinecone 2.0 — Edo Liberty, Pinecone at 1110 seconds](https://ai.engineer/api/talk-essay-media/9617e530144a1695a72cb7e1bb74019f3bf7036ade5759908a85a9ca974d6d24)

What the comparison measures—and what remains open

These are reported customer outcomes with limited detail about their measurement. Liberty does not give task definitions, sample sizes, or accuracy criteria. He does not explain whether the reported figures include the cost of constructing and maintaining the contexts. That matters because he has already described assembling company understanding as a substantial effort. The results suggest savings from avoiding repeated orientation, while leaving total economics and reliability across workloads unresolved.

Liberty ends by announcing that Nexus will move from early access into public preview the following day. The proposal’s hardest test remains his CEO example: can a maintained context reliably replace obsolete understanding when new information arrives? Curation provides a place to make that change, and persistent access lets many agents benefit from it.

## Key takeaways

- General competence and access to private documents do not supply the accumulated understanding of company processes, ownership, and priorities.
- A manifest specifies what a context should remember. Curation uses that manifest and a semantic map to update maintained knowledge across tables, notes, search indexes, and graphs.
- Freshness requires recognizing when a fact supersedes older information. Liberty explains the update path but leaves conflict-resolution rules unspecified.
- NoQL communicates the resources a question deserves. Nexus’s runtime coding agent writes, executes, and revises code during answering, producing code that can be saved and rerun.
- The reported reduction from roughly 150,000 tokens to fewer than 1,000 concerns tooling-interface descriptions. Customer token and speed gains include the advantage of prepared context; whether the figures include context construction and maintenance costs is undisclosed.

## Resources

- [Edo Liberty](https://edoliberty.com/) — Liberty’s research, engineering, and teaching background, including his work on long-term memory for AI.
- [Edo Liberty’s Pinecone writing](https://www.pinecone.io/author/edo-liberty/) — An index of Liberty’s Pinecone posts and publications, including writing on Nexus and agent workloads.

## Slides

### Theory of Mind

Edo Liberty uses Yahoo Answers to illustrate a mismatch between what people ask a product and what it can know: users asked “Am I fat?” even though the forum had no way to tell.

[0:25](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=25s) [Definition of theory of mind beside an illustrative Yahoo Answers screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ce103b66420a4d7a00df152e3c6a68f606674d812caa0adbc57805598a01a3f.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Theory of Mind

The capacity to understand other individuals by ascribing mental states to them.

Interface text:
New User? Register   Sign In   Help
Make Y! My Homepage
Mail   My Y!   Yahoo!
Yahoo! Answers Canada
Search   Search Web
HOME   BROWSE CATEGORIES   MY ACTIVITY   ABOUT
Ask
What would you like to ask?
Continue
Answer
Share your knowledge, Help others and be an Expert
Browse Open Questions
Discover
The Best Answers chosen by the Community
Browse Resolved Questions
What are you looking for?   Search Y! Answers   Advanced Search
Best of Answers
Is there a difference between flying and gliding?
Asked by Wintergreen D - Words & Wordplay
Gliding is done without the assistance of a mechanical... More >
87 [illegible] 38 [illegible] Answer by St N
Send to a friend
Ready to Participate? Get Started!
From the Answers blog
Facebook Fan Page
Since you can share your Answers content with your Facebook friends, it was logical to continue our collaboration with the social network. You can now become a fan of our official Facebook fan page!
Read the Answers Blog »
Share what you know. Answer open questions.
Recent   Popular   Show: All English questions
I am 14 and i play soccer with adults. I am the youngest, weakest, slowest. what should i do to get better.?
In Other - Soccer - Asked by [illegible] - 0 answers - 3 seconds ago
Like this page?
Save to del.icio.us
Add to My Yahoo!

### Three Kinds of Knowledge

Liberty distinguishes public general knowledge, company-specific facts, and tribal knowledge: the shared practices and priorities a seasoned employee knows but a single document may not capture.

[1:49](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=109s) [General, specific, and tribal knowledge compared using engineering, legal, and product examples.](https://assets.ai.engineer/sites/aiecode2025/sha256/0c0c9ed93cf07501cd1711d92f63838e250b67ed6f11c634e9b3768de8951ee5.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Three Kinds of Knowledge

01 General Knowledge

Engineering
Can I accelerate this function with this Rust numeric kernel?

Legal
Is this legal term common? What is its exposure?

Product
Is this a good use case for a product like ours?

02 Specific Knowledge

Engineering
Do we use a kernel for abstracting SIMD functions?

Legal
Which of our customers have this this term in their contract?

Product
Which of our customers use us or this use cases?

03 Tribal Knowledge

Engineering
Where do we choose to use SIMD vs not, and why?

Legal
When do we allow this term to be added to contracts and why?

Product
What new use cases are we prioritizing in the company?

### Agents Without Tribal Knowledge

Liberty compares an agent without tribal knowledge to a new hire: it lacks company context, must read documents to understand it, and starts most tasks from scratch.

[4:00](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=240s) [An agent without tribal knowledge is compared to a new hire lacking company context.](https://assets.ai.engineer/sites/aiecode2025/sha256/191cbba7264b8ccd20a9ecdc4abdc641b98141ab941bcb12c5e4d98df432f195.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Theory of mind:

Without tribal knowledge your agent “is” a new hire.

Brilliant. Tooled up.
High expectations.
No clue...

No context on goals, culture, or priorities, processes.

Has to read everything to understand anything.

Your agent does this from scratch every run.

### Agents Need a Knowledge Layer

Liberty proposes a persistent knowledge layer for company knowledge, processes, capabilities and goals, so agents have context across sessions.

[4:45](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=285s) [Statement that agents need a knowledge layer.](https://assets.ai.engineer/sites/aiecode2025/sha256/657dced444c3bae8b54d4cec3e1fe696811c4dbceb51c6e030b9ab63f3e40ae0.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Agents don't need to be smarter.
They need a Knowledge Layer

### What a Knowledge Layer Actually Does

Edo Liberty introduces his definition of a knowledge layer before explaining what Pinecone does.

[4:56](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=296s) [Section title introducing what a knowledge layer does.](https://assets.ai.engineer/sites/aiecode2025/sha256/c1be629df5e2b5430dd82f22364d303f68805747be52e31662c5be3abc89aea4.webp)

What a knowledge layer actually does

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
8

### A Knowledge Layer Should Be

Liberty proposes shared company knowledge that agents can reuse, domain experts can own and update, and companies can keep current by explicitly deprecating outdated information.

[5:05](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=305s) [A knowledge layer should be persistent, domain specific, and kept up to date.](https://assets.ai.engineer/sites/aiecode2025/sha256/77ddf6f335e0548f086e71b533200e3779a611140546a943be023dd1da4e5440.webp)

A knowledge layer should be

01 Persistent
Company knowledge is compiled from scratch only once (or very rarely)

All new agents have access to it.

02 Domain Specific
Specialized per domain - Support, HR, finance, product, inventory, ...

Owned by the relevant expert in the company.

03 Stays up to date
New Knowledge is added constantly.

Defunct information is explicitly deprecated

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
9

### A knowledge layer should not replace your entire stack

The agent accesses a separate knowledge layer alongside its LLM, tooling, local files and search. The layer groups KnowQL, Context Nexus and company knowledge.

[6:59](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=419s) [An agent connects to an LLM, tooling, local files, search, and a separate knowledge layer.](https://assets.ai.engineer/sites/aiecode2025/sha256/c3874c7d2debe283076cceb713bfa6509c9873a0c9df8396863c9581330d83fb.webp)

A knowledge layer should not replace your entire stack

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Your Agent

LLM
General Knowledge
KV Cache

Tooling
Web Search
SaaS Data

Local Files
Agentic “Search”
Session History

Search
RAG, Text, Semantic
Company Files

Knowledge Layer
KnowQL
Context Nexus
Company Knowledge

### Introducing Pinecone Nexus

Edo Liberty introduces Nexus as Pinecone’s knowledge layer.

[7:33](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=453s) [Title slide introducing Pinecone Nexus.](https://assets.ai.engineer/sites/aiecode2025/sha256/3e69875c8f712dbf80091ef99d99acfff401c5efe07663eece20a4f634ddc8c7.webp)

Introducing
Pinecone Nexus

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
8

### How Nexus Works

Nexus brings data in through connectors, organizes it into contexts and runs knowledge tasks. KnowQL provides a query interface for AI applications.

[7:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=466s) [Overview of connectors, contexts, tasks, and the KnowQL query layer alongside a system diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/ed8d62af504b9ffcdb1b655e9613f9561340939ed4f430242f4db401dddc45fb.webp)

How Nexus Works

Connectors - Getting data from anywhere
Contexts - Internal static artifacts
Tasks - Knowledge operations
Query - Agentic KnowQL layer

Your data, wherever it lives
Docs & wikis | Databases | APIs & SaaS | Object storage | Event streams | Code repos | ... more

Pinecone Nexus — Knowledge Engine

CONNECTORS
sources of data flowing into Contexts
Google Drive | Box | Slack | GitHub | Notion | Confluence | S3 | ... more

WORKSPACE
many workspaces per deployment

CONTEXTS
one per dataset
Context
Sources → Manifest → Knowledge
Manifest turns Sources into Knowledge
Context
Sources → Manifest → Knowledge
Manifest turns Sources into Knowledge
...

TASKS
Task runs a Workflow in a Sandbox
Sandbox
Task
Import
ingest & clean sources
Curate
build artifacts per Manifest
Search
query via KnowQL
each workflow may assemble multiple models as needed
...

Query Interface - KnowQL
The single interface into Nexus

Your AI Application
Chatbot / Q&A
Ask a question, get a grounded answer
AI Search
Search docs, products, or knowledge bases
AI Agent
Multi-step reasoning with retrieved context
Recommendations
Surface relevant items for each user
Reporting / Analytics
Query knowledge to generate insights

Interface text:
PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
10

### How Nexus Works: Connectors

Connectors bring data from many sources into Nexus while respecting source access controls. Liberty calls getting this right painstaking and important for enterprises.

[8:03](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=483s) [Connectors support many sources and respect source access control; the connectors section of the diagram is highlighted.](https://assets.ai.engineer/sites/aiecode2025/sha256/4f4580ae052fb10b6880447229d8cd4abc2a6221eb82597688815bdf374f1cdb.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
10

How Nexus Works

Connectors
• Support many sources
• Respect source access control

Your data, wherever it lives
Docs & wikis | Databases | APIs & SaaS | Object storage | Event streams | Code repos | ... more

Pinecone Nexus — Knowledge Engine

CONNECTORS
sources of data flowing into Contexts
Google Drive | Box | Slack | GitHub | Notion | Confluence | S3 | ... more

WORKSPACE
CONTEXTS
Context
Sources → Manifest → Knowledge
Context
Sources → Manifest → Knowledge

TASKS
Task
Import
Curate
Search

Query Interface - KnowQL
Your AI Application
Chatbot / Q&A | AI Search | AI Agent | Recommendations | Reporting / Analytics

### How Nexus Works: Context

A context groups sources, a manifest, and knowledge for a topic. The manifest describes goals and entities; Nexus maintains artifacts ranging from semantic maps and Markdown to SQL tables, vectors, and graphs.

[8:31](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=511s) [Context comprises sources, a manifest, and knowledge artifacts including semantic maps, files, tables, vector data, and graphs.](https://assets.ai.engineer/sites/aiecode2025/sha256/a65dda582287cee8312a7c8481d9d4c4472211c5d41c60d150886554aca19659.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
10

How Nexus Works

Context
• Source
  ◦ Connection details for source
  ◦ Temp stash of files to be processed.
• Manifest
  ◦ Instructions, goals
  ◦ Entities and terms
  ◦ Expected outcomes
• Knowledge
  ◦ Semantic map (catalog, schemas, glossary)
  ◦ Markdown files (per concept in manifest)
  ◦ SQL tables (structured data, aggregations)
  ◦ VectorDB (semantic + text search)
  ◦ Graph representations (entities, relationships)

Your data, wherever it lives
Docs & wikis | Databases | APIs & SaaS | Object storage | Event streams | Code repos | ... more

Pinecone Nexus — Knowledge Engine
CONNECTORS
Google Drive | Box | Slack | GitHub | Notion | Confluence | S3 | ... more
WORKSPACE
CONTEXTS — one per dataset
Context: Sources → Manifest → Knowledge
Manifest turns Sources into Knowledge
Context: Sources → Manifest → Knowledge
Manifest turns Sources into Knowledge
TASKS
Task
Import
Curate
Search
[illegible]

Query Interface - KnowQL
Your AI Application
Chatbot / Q&A | AI Search | AI Agent | Recommendations | Reporting / Analytics
[illegible]

### How Nexus Works

Nexus imports data, curates knowledge artifacts using a manifest and semantic map, and searches them with citations. Agents use KnowQL to specify the answer’s shape, grounding, budget and scope.

[11:42](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=702s) [Tasks include importing and parsing files, curating knowledge artifacts, and searching knowledge with source citations.](https://assets.ai.engineer/sites/aiecode2025/sha256/8ffe31f41e9582046b7987b0be82c1440a8446d9b1f8e62920ac578e3b68e372.webp)

How Nexus Works

Tasks
• Import
  ◦ Pulls raw files plus parse.
• Curate
  ◦ Used file(s), manifest, semantic map
  ◦ Builds/update the knowledge artifacts
• Search
  ◦ Knowledge retrieval (vector, sql, text, ...)
  ◦ Cite sources

Your data, wherever it lives
Docs & wikis | Databases | APIs & SaaS | Object storage | Event streams | Code repos | ...more

Pinecone Nexus — Knowledge Engine
CONNECTORS
Google Drive | Box | Slack | GitHub | Notion | Confluence | S3 | ...more
WORKSPACE
CONTEXTS
Context
Sources → Manifest → Knowledge
Context
Sources → Manifest → Knowledge
TASKS
Task runs a Workflow in a Sandbox
Sandbox
Task
Import
Ingest & clean sources
Curate
build artifacts per Manifest
Search
query via KnowQL
each workflow may ensemble multiple models as needed

Query Interface - KnowQL
Your AI Application
Chatbot / Q&A | AI Search | AI Agent | Recommendations | Reporting / Analytics
[illegible]

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
10

[13:25](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=805s) [Slide describing KnowQL queries and grounded answers for agents, alongside a Nexus architecture diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/158d94b857d9c4c3515c159a6df05a5afdb88d573b448f025b6630d4ac832f5d.webp)

How Nexus Works

Query
• KnowQL
  ◦ Declarative way for agents to ask for what they need: output shape, grounding, budget, scope.
• Agentic Behavior
  ◦ Agents get grounded answers back, not chunks to sift through and reason over.

Your data, wherever it lives
Docs & wikis | Databases | APIs & SaaS | Object storage | Event streams | Code repos | ...more

Pinecone Nexus — Knowledge Engine
CONNECTORS
Google Drive | Box | Slack | GitHub | Notion | Confluence | S3 | ...more
WORKSPACE
CONTEXTS
Context
Sources → Manifest → Knowledge
Context
Sources → Manifest → Knowledge
TASKS
Task
Import
Curate
Search
[illegible]

Query Interface - KnowQL
The single interface into Nexus
Your AI Application
Chatbot / Q&A
Ask a question, get a grounded answer
AI Search
Search docs, products, or knowledge bases
AI Agent
Multi-step reasoning with retrieved context
Recommendations
Surface relevant items for each user
Reporting / Analytics
Query knowledge to generate insights

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
10

### Pinecone Nexus: Under the Hood

The talk turns to how Pinecone Nexus works under the hood.

[14:33](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=873s) [Section title, Pinecone Nexus Under the hood, on a dark background.](https://assets.ai.engineer/sites/aiecode2025/sha256/e93183fbb888e6f48eec55ac1f56a6be3b5d1f1eec29df83ea11a986a497ab24.webp)

Pinecone Nexus
Under the hood

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
8

### Nexus Query Trace

Nexus traces an FB4 query and shows code generated for its first search. Liberty describes a runtime agent that writes and executes code at query time, revising it when results differ from expectations.

[14:57](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=897s) [Nexus interface displaying query steps, timing, token usage, cost, and generated code.](https://assets.ai.engineer/sites/aiecode2025/sha256/005c7d9f8897fe3cc732c062d92d48685e00f6c5c3bae14e7f99b4958ab21ca4.webp)

"tell me more about FB4 Systems"

STEPS: 5 + 1 answer
TOOL CALLS: 5
TOKENS: ↓ 48.6k ↑ 2,402
LATENCY: 21.1s
COST: $0.0094

TRACE · SPANS
Searching for artifacts related to "FB4" to get more cont[illegible]  2.7s
  search_knowledge()  RETRIEVAL
Searching for 'FB4' to find relevant artifacts.  3.3s
  search_knowledge()  RETRIEVAL
Reading the FB4 artifact to get details.  2.3s
  read_artifact()  FETCH
Reading the FB4 artifact directly.  2.0s
  read_artifact()  FETCH
Searching for more details on FB4 capabilities in the sou[illegible]  2.8s
  search_source()  RETRIEVAL
Answer  8.2s

INSPECTOR
Step 1
Searching for artifacts related to "FB4" to get more context.

TOKENS
↓ 5,419 ↑ 237

TIMING
2.7s total = 2.1s decide + 615ms execute

COST
$0.0008

GENERATED CODE
# Search for artifacts related to FB4
results = await search_knowledge("FB4 Systems", top_k=5)
for r in results:
    print(f"Artifact: {r.fields['artifact_name']}, Type: {r.fields['type']}, Summary: {r.fields['summary']}")

# I also want to see if there are any relationships for the FB4 artifact if it exists
relationships_fb4 = await relationships("FB4")
print(f"Relationships for FB4: {relationships_fb4}")

Interface text:
gemini-3.1-flash-lite
Cost detail

### Nexus and Traditional Agent Comparison

For the same renewal-discount question, Nexus returns a 12% discount in 2.47 seconds. At 7.11 seconds, the traditional agent has made two searches and is still gathering context.

[17:31](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1051s) [Side-by-side demo comparing a completed KnowQL response with an agent still searching contract information, including elapsed time, tool calls, and token counts.](https://assets.ai.engineer/sites/aiecode2025/sha256/74827f4f4864c9d9edb949157e55ac4e0e9768ce8e51a2b5c8025747730a005b.webp)

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
11

Nexus + KnowQL
TIME: 2.47s
TOOL CALLS: 1
TOKENS: 2,137

[illegible]
    {
      "rule_id": "LOYALTY_TIER_2",
      "reason": "3+ year customer, ARR > $500K",
      "confidence": "high",
      "source": "pricing_policy_v2026.md#loyalty-tiers"
    },
    {
      "rule_id": "ACME_OVERRIDE_2025",
      "reason": "Account-specific override supersedes standard loyalty",
      "confidence": "high",
      "source": "overrides/acme_corp_001.yaml"
    }
  ]
}
↳ returned KnowQL query · ~2,137 tokens

Based on my review, Acme Corp qualifies for a 12% discount based on their loyalty tier.
[done · 1 tool call · 2,137 tokens · 2.47s]

Traditional Agents
TIME: 7.11s
TOOL CALLS: 2
TOKENS: 14,059

$ agent --system traditional-agentic-rag

> Does Acme Corp qualify for a renewal discount?

Planning... I'll need contract terms, usage metrics, and policy rules.

⊙ tool_call #1 → search_contracts
args: "Acme Corp contract terms"
↳ returned 5 chunks · ~8,000 tokens added to context

Reading chunks... identifying current commitment tier. There's a reference to an amendment I don't have context on.

⊙ tool_call #2 → search_contracts
args: "Acme Corp amendment"
↳ returned 4 chunks · ~6,000 tokens added to context

### Three early access customer examples

Pinecone reports that Nexus used 85–97% fewer tokens and ran 18–77% faster than agentic RAG across three early-access cases, while being 14–94% more accurate.

[18:18](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1098s) [Three customer examples compare token use, speed and accuracy for Nexus against agentic RAG.](https://assets.ai.engineer/sites/aiecode2025/sha256/e78eb46a1d5189abce8524b5f542396b8a676d2a0004ab7f679f444b812753ba.webp)

Three early access customer examples

Nexus outperformed agentic RAG on accuracy, latency, and token cost across all three.

Patent Litigation
SEP claim validation against 3GPP standards. 97% fewer tokens, 77% faster, 25% more accurate.

Financial Services
Cross-document reasoning across 90-doc deal rooms. 92% fewer tokens, 48% faster, 14% more accurate.

SMS SaaS
Synthesis across 217 Gong transcripts. 85% fewer tokens, 18% faster, 94% more accurate.

Three of many. Every early access deployment is seeing the same result.

Interface text:
PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI
1

### Nexus public preview

Nexus is moving from early access to public preview tomorrow. Its bring-your-own-cloud deployment keeps customer data in their VPC.

[19:17](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1157s) [Nexus public preview is announced for tomorrow, with deployment in the customer's VPC.](https://assets.ai.engineer/sites/aiecode2025/sha256/af38b0feed6ec9f8909aa42e11b53333a04b7f2f243ddc5ecc0f39a3a3e3fcfc.webp)

What’s next?
Nexus in Public Preview Tomorrow!!

PINECONE: INFRASTRUCTURE FOR KNOWLEDGEABLE AI

Stay tuned
pinecone.io/nexus

DEPLOYMENT
BYOC — your data stays in your VPC

©2026 Pinecone - All Rights Reserved
13

### AI Engineer World’s Fair

[19:43](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1183s) [AI Engineer World’s Fair title card on a black background.](https://assets.ai.engineer/sites/aiecode2025/sha256/31776c80e8db19585a224d12f03ba95671ddc8b2d54a8dc07aa963744cf1b2eb.webp)

AI Engineer
World’s Fair

HTTPS://AI.ENGINEER

## Full transcript

[0:13](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=13s) All right. Welcome, everyone.

[0:18](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=18s) I wanna tell you a little bit about, uh, the new, the new, uh, knowledge layer, and, uh, I'll start with, uh, telling you a little bit about theory of mind. Uh, how many of you, uh, know what theory of mind is? All right, so a few folks. It's a, uh, term in psychology about, uh, our capacity to understand, uh, and have a mental state or a model of a mental state, uh, for other people. What do they know? What do they believe in? How do they act? That's, uh, what allows us to socialize, that's what

[0:48](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=48s) allows us to lie to each other, and so on. Uh, but it's a, a crucial developmental stage for humans, uh, and a necessary function. I'll, I'll sort of explain it in the best possible way with a funny story just to break the ice. Uh, about fifteen, sixteen years ago, I, uh, worked at a company called Yahoo, um, that had a product called Yahoo Answers, which was k-sort of like a Q&A forum. Uh, we used, uh, then AI, which is the Stone Age of AI, you know. It was like,

[1:18](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=78s) uh, NLP and other statistical models to answer questions. But the funny thing is people would come to, uh, Yahoo and ask questions like, "Am I fat?" Which, uh, is funny because obviously, uh, uh, you know, a Q&A forum would-wouldn't have any clue whether you're, you're too fat or not. Uh, but this is a funny way to say, yeah, people have a very bad theory of mind on sort of what the products that they use, what information they have and what they don't

[1:48](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=108s) have. And I wanna argue that in some sense, we are making that mistake with AI today in a more subtle and less sort of like, uh, silly way, but in a just as a fundamental of a mismatch. And so I will categorize roughly three kinds of knowledge. I think there are, there are many more, but, you know, in broadstro-- in broad, broad strokes, this is not a bad way to categorize. First of is, is, uh, general knowledge. Think about that as what's available in the public

[2:17](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=137s) domain, things that models are trained on, and we expect an LLM to just know out the gate. Uh, things about just, you know, uh, improving your, uh, Rust code, uh, asking you like, rec-- you know, explaining stuff about the legal terms or, uh, sort of exploring use cases for, for products. Um, w-we know how to do that. Models are really good at that. When we use our agents, they have that information. There is specific knowledge  the companies... Of course, the models wouldn't

[2:47](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=167s) have, uh, any clue about whether we've, uh, implemented something specific in our code base, what a contract of a specific customer has. Of course, this is information that's private to the company, uh, but we know how to deal with that. And RAG and search and of course, uh, Pinecone, VectorDBs, and so on, uh, solved these problems a long time ago. There's still a lot to go, but we by and large know how to do it. And then I would say there is tribal knowledge, okay? Tribal knowledge

[3:17](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=197s) is the sort of general knowledge inside the company. This is the kind of information that, uh, an emp-- a seasoned employee has that a new hire does not, okay? It's roughly how we do things, what our processes are, who's in charge of what, uh, what are the guiding principles, what are the-- you know, sort of how we get stuff done in this company, okay? Um, that is not a s-- that's not general knowledge because it's, it's specific to your company, but it's also not a s-specific piece

[3:47](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=227s) of knowledge because you can't just get it by searching. You can't just get it by plucking it off one place and say, "Yes, this document says, uh, that this is our culture." It's the sum total of a lot of, uh, things. Um, and so if our theory of mind of most of our agents in big companies today should be something like a new hire. They're brilliant, they have tools, they have-- we have very high expectations of them, but they are by and large clueless, okay? They have no idea about your

[4:17](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=257s) company's goals, culture, priorities, processes. Um, uh, they have to read a bunch of documents, uh, to be able to get any semblance of understanding of where they are in the world. Um, and really, they start most tasks from scratch, okay? They really start-- kinda wake up, and every time you start y-your session, uh, they're like a new hire on their first day on the job.

[4:47](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=287s) So I would argue that what they need is not necessarily to be smarter, to have better tools, but to have something new, which I would call a knowledge layer going forward. Um, and, uh, I have to explain to you what I think a knowledge layer has to actually do. But just I'll define it generally before I explain to you what we do. Um, so at the very least, it needs to be persistent. We talked about this as the company knowledge, processes, uh, capabilities, and, uh, goals, and so on.

[5:17](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=317s) It has to be persistent. Uh, it sure-- it, uh, feels like putting this thing together is going to be a monumental effort, so you wanna do it once or at least very rarely. Uh, and of course, all your agents in the company need to have access to this thing. The second thing is that, uh, you would argue that this knowledge layer needs to be, uh, highly specialized. If your agent, uh, is in charge of HR practices or optimizing your, uh, your kernels, uh, in your code base or,

[5:47](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=347s) uh, resolving customer issues, that they would care about different things. They would wanna, you know, address-- They would wanna have different information available to them. Um, and I would argue irrelevant of, of specifically how it's created, I would argue that it's a good practice to have the domain experts in the company own those and have b-being able to interact with them and make sure that they actually, uh, are aligned with what the company wants to do. And finally, which is the hardest thing, is they

[6:16](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=376s) need to stay up to date, and they need to stay concurrent constantly because companies change, and you need to make information, uh, uh, deprecated when it becomes deprecated. If the company replaces its CEO, the very next day, everybody in the company knows who the CEO is, okay? Even though nine thousand documents going from, you know, a day before yesterday to, uh, the last ten years say it's somebody else. This has become

[6:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=406s) common tribal knowledge immediately and everything else, even ev-- you know, every RAG, uh, search will tell you otherwise, this is now the overriding fact. Okay? Um, I will argue before we move on that I'm not suggesting that this knowledge layer should replace everything else we're doing. Our agents are already very capable and should keep being very capable. Uh, they have access to LLMs, of course, uh,

[7:16](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=436s) tooling, local files, search, of course, like RAG, vector search, text search, and so on. And I would argue that, uh, the knowledge layer needs to be a separate entity that all these agents have access to, as, as I explained, uh, why this is sort of a fundamentally different kind of data source. So I wanna tell you more about Nexus. Um,

[7:40](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=460s) um, Nexus is a product that we're, uh, uh... Of course, it's a knowledge layer, but I need to-- I wanna explain to you what it does. Uh, of course, uh, so the, the four parts are roughly connectors, what I would call context, uh, uh, tasks, and queries. I'll explain each one of them, uh, now. So connectors, of course, do the obvious things. There's nothing much to talk about them. Um, uh, they bring

[8:10](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=490s) data into the platform, uh, re-respect access, uh, rights and, uh, and control, and so on. Um, very dull as a topic of discussion, but incredibly important in enterprises, incredibly important to do right, uh, and everybody who's built that knows how painstaking it is to get this thing to work well. Um, the interesting-- Sort of the first, uh, properly interesting part is, um, the

[8:40](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=520s) context. So the context, think about that as the, um, the sum of assets that the, that Nexus or this knowledge layer saves about a specific topic. Think about this as a context for HR, for operations, for engineering, and so on. Okay? Of course, it has the sources, the connections to the data, and so on. But then it has the manifest. Okay? The fe-- manifest is the first truly novel

[9:10](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=550s) idea and, and a, uh, important, uh, uh, entity. Okay?

[9:16](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=556s) The way that we today give context to our agents is with skills and plugins and, uh, commands and sort of markdown files they write ourselves. In a knowledge layer, you don't do that anymore. Okay? You tell the n-- you tell the knowledge layer, you tell Nexus what you care about in a manifest. You say what kind of tasks you're, you wanna complete, what entities you wanna track, what kind of information you care about. And it's, it's the knowledge layer's

[9:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=586s) work to keep track of those files, okay? And, and organize its own data. Um, uh, and then it has the knowledge files themselves. So think about the manifest as the meta knowledge, uh, file or set of files. Um, and then there's the knowledge. The knowledge itself, uh, think about this as five types of contents. One of them-- The, the first kind is a semantic map. Okay? This is a file that

[10:15](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=615s) organizes the catalog of where everything else is, the key schemas, the glossaries, all the information that you need to be able to operate this context. Then there are, of course, a bunch of markdown files that contain information, decisions, memories, uh, all sorts of unstructured information. If you've, uh... Who here has, uh, heard about, uh, uh, LLM Wiki? Okay. So LLM Wiki is this, uh,

[10:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=646s) idea that Andrej Karpathy suggested to have agents basically, uh, manage some stash of markdown files to sort of keep their own notes of stuff. This is a very similar idea, okay? Sort of on steroids, but similar concept. But that's not enough. The context contains also a bunch of SQL tables for tabular data, for aggregation, for facts that they need to memorize. Uh, a vector database, uh, to be able to semantically search and text search and filter a bunch of

[11:15](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=675s) information and all the information that it itself decides is necessary to keep and, and remember. And graph entities and graph indexes to remember, uh, again, entities, relationships, uh, causal chains, and so on. Okay? And all of that is managed and created for you. You don't touch any of this. You don't have to, uh, know how any of this is created. It's all maintained through the manifest. So these are-- this is

[11:45](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=705s) the context. Now what are the tasks? What are the actions? These are the nouns. What are, what are the verbs? What can we do with those, uh, objects? Uh, first of all is, of course, import, which is bring new information in the system, new files, new events, uh, new, uh, concepts. Um, curate is probably the most and most elaborate, uh, so one of the two most elaborate functions. Its, uh, job is to take, um, to take the- Uh, then

[12:15](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=735s) say call it a file. It doesn't have to be a file, but let's say it's a new PDF or a new meeting transcription or a new, uh, presentation for the board and say, "Now I need to update my view of the world." Okay? So it takes that, it takes the manifest, which tells, okay, now what, what things do I care about? What concepts do I need to track? What, uh, needs to be, uh, uh-- What do I need to memorize here? And then it takes the semantic map that I told you contains all the in-- like, organizes where information is

[12:45](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=765s) and understands, okay, fine, I need to go update these tables, these relationships to my graph, uh, this, uh, these text indexes and so on. Um, and when it's done, it has essentially said, "Okay, fine. I have assimilated the new information." Uh, it's already-- It's, it's sort of persisted in your context, and we can move on. Okay? Search is sort of a internal function, very important. It basically abstracts with simple

[13:15](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=795s) functions, all the access to that information so that the agent, that I'll tell you in a second, doesn't have to know, uh, how to sort of access the internal parts of the context. Now comes, uh, the second, I think most, uh,

[13:32](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=812s) most, uh, interesting, uh, part of, of the system, which is NoQL. NoQL is our way to s- to, uh, specify how we want information out of the context. It's not enough to just ask questions. If you're an agent, it's really important for you to give us the budget in tokens or in dollars, how much time you want us to invest in this. Sort of like, do you want us to-- just a quick off-the-cuff, uh, kind of immediate answer, or do you want us to go full tilt and

[14:02](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=842s) scour everything we know to make sure we give you the most accurate answer, uh, and so on. So the structure and, and so on. It's, you know, it's, it's an agentic tool. This is not like a chat interface. Okay?

[14:15](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=855s) Um, and of course, what you get back is like something that's agent-friendly. This is, uh, you know, grounded text and, and kind of structured in the right way. Format. This, again, is not designed to be like a chat interface. This is really what your agents expect. Okay? Um, so this is, this is a, uh, um, this is a, uh... Trying to figure out how much time I have.

[14:46](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=886s) Okay, I need to go a little bit faster. So,

[14:50](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=890s) uh, this is a, uh, sophisticated crowd. I wanna sort of, uh, pop the hood and show you a little bit about how things work. So, uh, if anything, uh, this is the interface. I wanna--

[15:03](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=903s) There are many, many cool ideas, uh, that make this work, but I wanna tell you a little bit about just one of them. Okay? What you're seeing is the interface for Nexus. Okay? You will see at the top a question, uh, that, uh, the, uh, the agent, uh, issued, and you see, you see on the left, uh, the different steps that it went through. Okay? What you see on the bottom right is probably the most interesting. You see generated code on the bottom right. What Nexus

[15:33](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=933s) does, which is very different than other systems, it's what we call a runtime coding agent. Okay? Unlike other coding systems in, in-- that, that you're used to, uh, where the task is, uh, take a large code base and then help me edit it, right? But when the edits are done, what I have is a piece of software, and that is deployed. That is the artifact. Okay? What is running does not contain the model anymore. It's just

[16:03](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=963s) the code. Okay? This is not what's happening here. The-- In query time, you should think about the engine essentially building something like a Jupyter Notebook, something like, uh, like a Python REPL, right? And they literally write code and execute it and write code and execute, and if they get the answer, they know what to do with it. And if it's, you know, if it's not what they expected, they rewrite that piece of the code. And what you get in the end is a, is a piece of code

[16:33](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=993s) that completes the task, that gets the information that you wanna get. Okay? That is savable, that's re-runnable. Okay? But it's also incredibly flexible because now the, the answer is got not by, by a query to a database. It's wr- it's written by code, which is in, of course, incredibly flexible. Okay? That code is, by the way, interestingly enough, if you replace-- if you write software this

[17:03](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1023s) way, the, the amount, the, the amount of prompting that you need is significantly reduced. We went down from having something like a hundred and fifty thousand tokens to give our agents all the tooling they need to less than a thousand tokens to specify all the interfaces they need to get information out of Nexus. Okay? And so the ans-- the, the... So what it looks like when you run it is like this. Okay? So on the left, of course, you'll see Nexus with, uh, uh,

[17:32](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1052s) NoQL answering the question. And then on the right is sort of-- is the same, uh, task given to an agent with all the tooling to complete the task. Okay? But remember this on the right, it's, uh, severely handicapped. It's like the employee on the first day on the job. They have to read a bunch. They have to figure out where the data is. They have to figure out what the task is. They have to write a bunch of code. Uh, it's just, it's just severely handicapped. And there's, uh... It's just, I don't know if you... Okay, it stopped. But,

[18:02](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1082s) um, needless to say, this is by far slower. It's a lot more expensive in terms of token consumption. Uh, but interestingly enough, it's also a hell of a lot less accurate because, again, they don't have the right context, the right objectives and so on in your company. Um, I'll just say that  we work, uh, obviously with a bunch of, uh, early access customers already. Uh, you see some results here, but I'll just sort of fly through them and say

[18:32](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1112s) that across different domains, ac-across different enterprises, across different kinds of tasks, you will universally see the same thing. That if you shift to this paradigm, you get significant cost savings. Uh, seventy-seven, ninety, you know, percent token cons-- token reduction is pretty common. Um, uh, it gets a hell of a lot faster, anywhere from twenty, thirty percent to sometimes, uh,

[19:02](https://www.youtube.com/watch?v=IN-rb-9WmiY&t=1142s) uh, uh, seventy-seven percent faster. Okay? But-- And the most important thing is it actually becomes a lot more accurate as well in the same time. So this is really, uh, it's a slam dunk. I'll just wrap up by saying that, uh, um, the, that Nexus is coming out of early access and into public preview literally tomorrow. So go, uh, try it out.
