Edge 2.0 Architecture

Everything Snir's team walked through about how Edge 2.0 is built—the protocol, the components, the constraints.

GUI Protocol

Edge 2.0 uses a GUI event protocol in TypeScript. Not Python. This is a hard constraint for any prototyping work.

Event Stream

Six event types: message_start, content, tool_calls, activity_snapshot, run_start, run_finish. The frontend consumes these to render the conversation in real time.

Streaming protocol

Activity Snapshots

Signal the frontend that a UI component is about to be rendered. The snapshot triggers placeholder insertion and component preparation. Used for typing indicators, live agent transitions, and component rendering.

Component trigger

History API

Fetching stored messages returns full content (not deltas) plus entire component payloads as JSON. The payloads are "pretty big—room to improve" per Snir. Supports both GUI protocol and stored history formats.

Data layer

Placeholder System

Components are injected into assistant messages via a placeholder mechanism. This is the core rendering pattern for all UI in Edge 2.0.

Placeholder → Component Flow
backend.emit activity_snapshot { type: "flight_results" } TRIGGER
placeholder.insert {{FLIGHT_RESULTS:inst_7a3f}} into assistant content INJECT
placement.spec position: block, line: 2, component_type: flight_results LAYOUT
frontend.render capture placeholder → replace with <FlightResults /> RENDER
Input area replacement: Components can also replace the chat input itself. Example: credit card collection swaps the input for a form. All interaction stays near the input—no drawers, no modals. The user fills the form or returns to chat.

PLACEMENT

Per-Placeholder Instructions

Each placeholder gets specific layout directives: first line, second line, block, inline. Multiple placeholders can coexist in the same message. The frontend knows how to place each one independently.

INSTANCES

Unique IDs per Component

Every placeholder carries a component_type and instance_id. Multiple components of the same type can appear in a single conversation turn without collision.

Run Lifecycle

A "run" = user sends a message, system processes, returns response. Two hard constraints shape the interaction model.

CONSTRAINT

No Concurrent Messages

User must wait for the current run to finish before sending another message. No queuing, no interruption. This limits how iterative the conversation can feel during long operations like flight search (~42s).

GAP

No Stop / Cancel

No stop icon. Not currently planned. Farid flagged this: users make typos, notice autocorrect errors, want to abort before booking the wrong destination. Navan acknowledged the product value but noted the complexity: "If you're in the middle of booking and click stop—what happened? Booked or not?"

Agent Architecture

Edge 2.0 uses a swarm pattern. The main agent orchestrates everything; specialists handle domains; live support is a separate track.

Main Travel Agent

Orchestrates all sub-agents. Maps their responses to UI components. Decides whether 10 results get a carousel or 1 result gets an inline card. Controls conversation flow and context.

Specialist Sub-Agents

Domain experts: flights, hotels, and more. Each returns structured data to the main agent. The sub-agent protocol is "less interesting for you" per Snir—what matters is how the main agent maps responses to UI.

Live Support Agent

Mutually exclusive with AI mode. Once the user enters live agent, they stay there until explicitly exiting. Cannot mix AI and live agent in the same turn. Hard separation.

Mobile Strategy

Must support both web and iOS. Old mobile versions must remain supported—adding new components is constrained by the install base.

PRIMARY APPROACH

Web View Fallback

If a new component isn't supported natively on mobile, it loads as a web view inside the chat frame—not a browser redirect. Web view communicates back to the iOS app: button clicks trigger iOS events, component reports its size. Can use server-side rendering or send raw HTML. Claude app already does this with Booking.com components. Farid validated the approach.

CONSTRAINT

Legacy Version Support

Old mobile app versions must continue working. Every new component needs a degradation path. The web view fallback solves this: if native doesn't support it, web view does. Text-only fallback is the last resort.

FUTURE VISION

Multi-Channel

Navan eventually wants Edge on multiple channels. Farid cautioned that a chat-only interface limits continuity for complex trips. Not the current focus, but it shapes architecture decisions.

Farid's suggestion: Apps can load component packages on demand and cache them locally. Good option for unusual or partner components that don't need to ship with every app update.

Feature Parity

Edge 2.0 is not at feature parity with 1.0. Each version has strengths. We should design for the combined best-of.

EDGE 2.0 WINS

Architecture & Latency

LangGraph-based architecture. Better conversation experience infrastructure. Faster response times. The foundation is stronger even if not all features are built yet.

latency LangGraph conversation UX

EDGE 1.0 WINS

Hotel Flows

Hotel search logic and hotel conversation quality are better in 1.0. The search results, profile pages, and booking funnel are more mature. "Look at both" per Navan—and imagine combining the advantages.

hotel search conversation quality booking funnel
Cognition (proprietary) → LangGraph (new architecture)

Glossary

COGNITION
Navan's previous proprietary platform. Being replaced by a LangGraph-based architecture.
LANGGRAPH
The new agent orchestration framework. Referred to as "Langov" in the transcript (possibly a transcription artifact or internal name). Our prototypes will use LangSmith.
ACTIVITY SNAPSHOT
GUI event that signals the frontend a UI component is about to render. Triggers placeholder insertion.
PLACEHOLDER
Unique symbol inserted into assistant message content. Contains component_type + instance_id. Frontend captures it and replaces with the rendered component.
SWARM
Agent orchestration pattern. Main travel agent delegates to specialist sub-agents (flights, hotels, etc.) and maps their responses to UI components.
DRAFT TRIP
A trip entity with just a date and destination—no booking required. Exists in the system but not currently surfaced in the UI. Navan wants to bring them back.
RUN
A complete message cycle: user sends, system processes, response returns. No concurrent runs allowed. No mid-run cancellation.
SPLIT
Feature flag / A/B test group. Snir mentioned adding our team "to the split" to access Edge 2.0.
EDGE 1.0
Current production version. Better hotel flows. Runs on the Cognition platform. What users see today in the app.
EDGE 2.0
New version on LangGraph. Better latency and architecture. Not yet at feature parity with 1.0. What we demoed in this meeting.