← Back to Hub
Anything Engine · Architecture

The Anything Engine
14-Class Intent Dispatch

Natural language input → intent classification → specialized backend tool. One front door for every relationship outcome Orbiter can drive.

Apr 28, 2026 · Xano API Group 1270 · UgP1h6uR
At a Glance
14
Intent Classes
4
Live Tools
10
In Progress
3
API Endpoints
What It Is

The Anything Engine is Orbiter's intent classifier and dispatch system. A user types any natural language query — "find me investors for our Series A" or "who at LSI should Henry meet?" — and the engine classifies it into one of 14 outcome types, then routes it to a specialized backend tool that runs the appropriate graph query, embedding search, and synthesis pipeline.

The classifier runs on Groq Llama 3.3 70B at near-instant latency. Every response includes a confidence score and reasoning trace, so the router knows when to confirm with the user before dispatching.

Architecture principle: Xano = orchestration layer. AlloyDB = data layer. Next.js sandbox = UI + thin BFF only. Business logic never lives in Next.js routes — it always routes through Xano.
Dispatch Pipeline
Input
Natural Language
Classify
Groq Llama 3.3 70B
Route
Tool Selection
Embed
OpenRouter 1536d
Query
FalkorDB Cypher
Synthesize
Groq + Opus 4

FalkorDB is interim. AlloyDB + ScaNN swap pending — same Cypher pattern, higher throughput, 6 vector dimensions per investor.

The 14 Intent Classes

Every query collapses into one of these canonical classes. The classifier returns the class name, confidence (0–1), and reasoning. LIVE = tool implemented and deployed. PENDING = classified correctly, backend not yet wired.

LIVE
find_investors
Fundraising: match VCs and angels to a company's stage, sector, and thesis.
LIVE
find_talent
Recruiting: surface candidates with relevant experience from the network graph.
LIVE
find_customers
Business development: identify potential buyers or design partners.
LIVE
research_person
Deep person research: career path, investments, board roles, writing, context.
PENDING
research_company
Company deep-dive: funding history, team, investors, market position.
PENDING
research_topic
Thematic research across the graph: trends, clusters, emerging signals.
PENDING
find_partners
Strategic partnerships: complementary products, integration candidates, channel partners.
PENDING
find_advisors
Advisory board: domain experts and operators who've solved the same problem.
PENDING
find_co_investors
Syndication: co-investors who've backed similar rounds or co-invested before.
PENDING
find_journalists
PR targeting: reporters covering the relevant beat and sector.
PENDING
find_event_attendees
Conference targeting: filter a cohort by role, company, and relevance.
PENDING
find_warm_intros
Path-finding: 2nd/3rd degree paths to a target via mutual connections.
PENDING
summarize_meeting
Meeting intelligence: extract decisions, commitments, and follow-ups from transcripts.
PENDING
plan_outcome
Goal planning: break a desired outcome into ranked, actionable steps with network leverage.
API Reference
API Group: Anything Engine — ID 1270, canonical UgP1h6uR
Base URL: https://xh2o-yths-38lt.n7c.xano.io/api:UgP1h6uR
Live Demo: orbiter-sandbox.vercel.app
ID Method Path Purpose
8400 POST /classify Run intent classifier, returns class + confidence + reasoning
8399 POST /dispatch Full pipeline: classify → embed → query → synthesize → Crayon cards
8401 POST /find-investors Dedicated investor-search endpoint (reference implementation)

Classify — Request

POST /api:UgP1h6uR/classify
Content-Type: application/json

{
  "query": "We're raising a $3M seed. Who should we talk to at LSI?",
  "user_id": 15
}

Classify — Response

{
  "class": "find_investors",
  "count": 1,
  "confidence": 0.97,
  "reasoning": "The query explicitly mentions fundraising context ('raising a $3M seed') and requests investor introductions scoped to a specific event (LSI). This maps directly to find_investors with high confidence."
}
When to confirm before dispatch: If confidence < 0.75, surface the classification to the user and ask for confirmation before routing to the tool. This prevents mis-dispatches on ambiguous queries like "who should I talk to?" without enough context.

Full Dispatch — Request

POST /api:UgP1h6uR/dispatch
Content-Type: application/json

{
  "query": "Find seed-stage VCs who invest in AI infrastructure. $3M round.",
  "user_id": 15,
  "context": {
    "pitch_deck_text": "We build...",
    "live_event_id": 3,
    "zep_thread_id": "thread_abc123"
  }
}

Full Dispatch — Response Shape

{
  "class": "find_investors",
  "confidence": 0.94,
  "results": [
    {
      "master_person_id": 1847,
      "name": "Kai Nguyen",
      "firm": "Gradient Ventures",
      "fit_score": 0.91,
      "rationale": "Gradient led two AI-infra seed rounds in 2024...",
      "why": "Thesis match on AI tooling + infra. Check size $1–5M. 3 portfolio companies in adjacent space.",
      "draft_outreach": "Subject: AI infra seed — Orbiter intro via [name]..."
    }
  ],
  "mem_used": true,
  "process_id": "proc_7c2f4d"
}
Classifier Internals
Model

Groq Llama 3.3 70B — chosen for near-zero latency (<300ms) at high accuracy on intent classification tasks. Temperature 0.1 to minimize variability.

Output Schema

Structured JSON with class (enum of 14), confidence (float 0–1), count (number of intents detected), and reasoning (plain text).

Multi-Intent Handling

count indicates how many distinct intents were detected. When count > 1, the dispatcher either sequences multiple tool calls or surfaces a clarification prompt to the user. The primary class with highest confidence dispatches first.

// Multi-intent example
{
  "class": "find_investors",
  "count": 2,
  "confidence": 0.88,
  "reasoning": "Query has two intents: find investors (primary) and research the lead investor from their last round (secondary). Dispatching find_investors first, queuing research_person."
}

Prompt Engineering

The classifier prompt is stored in an editable Mintlify doc — never buried in TypeScript. Key elements:

Architecture Principles
Xano = Orchestration

All business logic, prompt assembly, graph queries, and synthesis live in Xano endpoints. Xano is the source of truth for pipeline behavior.

AlloyDB = Data

Investor profiles, vector embeddings (6 dimensions), and relationship graph data. AlloyDB ScaNN handles hard filters + semantic in a single SQL call.

Next.js = Thin BFF

UI only + a thin backend-for-frontend. Routes call Xano and stream SSE to the Crayon SDK. Zero business logic in Next.js route handlers.

Migration status: The sandbox currently uses FalkorDB (interim) for graph queries. AlloyDB ScaNN migration is the next major milestone. The Xano orchestration layer is database-agnostic — swapping the data layer requires no changes to the dispatch or classify endpoints.

Data Flow

User Query (NL)
Next.js API route (/api/find-investors)
↓ POST
Xano /classify (8400) → {class, confidence, reasoning}
↓ if confidence ≥ 0.75
Xano /dispatch (8399)
↓ embed query (OpenRouter text-embedding-3-small)
↓ FalkorDB Cypher (VC_Firm + Angel, multi-hop)
↓ Groq synthesize (per-person rationale)
SSE stream → Crayon card renderer
Zep memory update (thread context)
Rendered contact cards in UI
Zep Memory Layer

Every dispatch call checks Zep for prior user context. On turn 2 with a vague follow-up query ("show me more like the last one"), the memory layer provides the missing context needed for the classifier to produce a confident routing decision.

Thread Context

Each user session has a Zep thread. The dispatcher fetches thread.get_user_context before classifying. Context includes: recent queries, dispatched classes, and entities mentioned (companies, people, sectors).

mem_used Flag

Response includes "mem_used": true when Zep context influenced the classification or tool parameters. Lets the UI surface a "remembered from earlier" indicator.

Live Sandbox
Live at: orbiter-sandbox.vercel.app — The find_investors flow is the reference implementation. Type a natural language fundraising query and watch the full classify → embed → query → synthesize → Crayon card pipeline run end-to-end.

Stack: Next.js 14 App Router · WorkOS auth · Crayon SDK · SSE streaming · FalkorDB (interim) · Zep Cloud memory
ToolStatusGraph PatternNotes
find_investorsLIVE E2EVC_Firm + Angel, portfolio/co-inv hops, score < 0.85Reference implementation. Zep wired.
find_talentLIVE E2EPerson labels, role/company/skill edgesReturns ranked candidate cards.
find_customersLIVE E2ECompany + Person, sector/stage filtersBD targets with warm-path drafts.
research_personLIVE E2EPerson enrichment + entity graphDeep bio, investments, board seats.
remaining 10PENDINGTBD per toolClassified correctly; backends in backlog.
What's Next
AlloyDB ScaNN Migration

Swap FalkorDB (interim) for AlloyDB with 6 ScaNN vector indexes per investor: sector, stage, check_size, geography, signal, founder_fit. Single SQL call combines hard filters + semantic similarity.

Lock Canonical Class Names

The 14 class names above are the canonical set. UI labels, classifier prompt, and dispatcher all must use the exact same strings. Canonical lock is pending sync with Mark.

Per-Mode Context Floors

Each tool has a minimum required context spec. find_investors requires pitch context (deck or description). find_talent requires JD or role context. The dispatcher surfaces a context-gap card when floor is not met.

Remaining 10 Tools

The classifier already routes all 14 classes correctly. Building backends for the remaining 10 follows the find_investors reference pattern: Cypher template → Groq synthesis → Crayon card schema.