The AI behind elvaro
"AI" has become a label stuck on everything. This page explains — in plain language — what the technologies actually are, how they differ, and how elvaro combines them.
What a large language model (LLM) is
A large language model is a neural network trained on enormous amounts of text until it becomes remarkably good at one thing: understanding and producing language, including the reasoning expressed in language. That makes LLMs the first AI technology that can read a messy, human question — "should I take some profit here or let it ride?" — and understand what's actually being asked.
But an LLM alone has two famous weaknesses. Its knowledge is frozen at training time — it knows nothing about today's market. And when it doesn't know something, it can generate plausible-sounding text anyway (what researchers call hallucination). For casual conversation that's an annoyance. For trading, it's disqualifying.
From LLM to agent
An agent is what you get when you give an LLM the ability to act: to call tools, fetch live data, run computations, and check its own work before answering. The LLM contributes what it's best at — understanding your question and reasoning about evidence — while the facts come from live systems, not from memory.
This is the key design idea in elvaro: the LLM never does the math and never supplies the facts. Prices, indicators, and market numbers come from data systems built for precision. The LLM's job is to understand your question, decide what evidence is needed, and explain the conclusion in language you can act on.
The anatomy of an AI agent
Every serious agent — elvaro's included — runs a version of the same loop, borrowed from decades of AI research and supercharged by LLMs:
What separates a production agent from a demo is what surrounds this loop: orchestration deciding which agent runs, tools giving it hands, memory giving it continuity, and guardrails keeping it honest. All four are covered below.
The wider AI toolbox
Modern AI in finance isn't one technique — it's a stack. Here's the honest map of what each piece does:
| Technique | What it is | Where it shows up in trading |
|---|---|---|
| Data analytics & statistics | Computing precise quantities from raw data: moving averages, RSI, MACD, volatility, correlations. | The backbone of every elvaro answer — indicators are computed deterministically, the same way every time. No hand-drawn trendlines, no eyeballing. |
| Natural language processing (NLP) | Teaching machines to read and interpret human text at scale. | Reading market narrative and sentiment — the mood of the crowd, summarized instead of doom-scrolled. Fear & Greed-style indices are sentiment analytics. |
| Machine learning (pattern recognition) | Models that learn statistical patterns from historical data instead of following hand-written rules. | Signal research: finding conditions that historically preceded moves, and scoring setups by confidence rather than gut feel. |
| Reinforcement learning (RL) | An agent learns by trial and error — taking actions, receiving rewards or penalties, improving its policy over time. The technique behind game-playing AIs like AlphaGo. | Used by quant funds for execution and strategy optimization. Powerful but data-hungry and risky to deploy naively — markets change, and a policy trained on yesterday's market can fail in tomorrow's. |
| LLM reasoning & orchestration | Language models that understand goals, plan multi-step work, and coordinate tools. | elvaro's coordination layer: turning your question into a research plan, delegating to specialists, and synthesizing evidence into an answer. |
elvaro's architecture combines the rows that serve you best today: LLM reasoning on top, deterministic analytics underneath, sentiment and market data feeding both — with the multi-agent structure described in how elvaro works. We deliberately don't let a model "predict" prices from memory, and we're skeptical of anyone who claims theirs does.
Agent systems: the technical vocabulary
If you read about AI agents, these are the terms that matter — and what each one means inside elvaro.
Agent orchestration
Orchestration is the control layer that decides which agent handles what, in what order, with what context. elvaro uses a coordinator–specialist pattern (also called a supervisor or router pattern): a coordinator agent classifies your intent — market question, signal request, position discussion — and dispatches the work to the right specialist, then assembles their outputs into one coherent answer. The alternative patterns you'll see in the literature — sequential pipelines, debate/consensus setups, hierarchical trees — trade latency against depth; the supervisor pattern is the sweet spot for conversational speed.
Multi-agent systems & agent swarms
A multi-agent system splits a problem across several agents with distinct roles, prompts, and toolsets — exactly how elvaro separates its market analyzer, trader, and portfolio-context specialists. The term swarm describes the looser version: many agents cooperating with lightweight handoffs rather than a rigid hierarchy. Why split at all? Three reasons: focus (a specialist with ten relevant tools outperforms a generalist with fifty), parallelism (specialists can research simultaneously), and auditability (each agent's contribution can be traced and evaluated independently).
Tool use & function calling
Function calling is the mechanism that turns a language model into an agent: the model emits a structured request — get_price(BTC), compute_rsi(ETH, 14d) — the system executes it against a real API or computation engine, and the result is fed back into the model's context. elvaro's specialists have access to a toolbox spanning market data, technical analysis, onchain activity, and sentiment. Every fact in an answer entered the conversation through a tool call — which is what makes answers auditable rather than hallucinated.
Memory
Agent memory comes in layers, and the distinction matters:
| Layer | Technical name | In elvaro |
|---|---|---|
| Working memory | Context window | The current conversation plus the data the agents just fetched — what the model is "holding in its head" right now. |
| Session memory | Conversation state | Your chat history within a session, so follow-up questions ("and what about ETH?") resolve correctly. |
| Long-term memory | Persistent profile store | Your trader profile — goals, risk tolerance, preferences, positions you've shared — retrieved and injected into context on every question. |
This layering is why elvaro doesn't ask you the same questions twice, and why answers stay personal across sessions without retraining any model.
Grounding & retrieval (RAG)
Retrieval-augmented generation means the model's answer is generated from documents and data retrieved at question time, not from training memory. elvaro applies the same principle to market data: every answer is grounded in a fresh retrieval pass — live prices, computed indicators, current sentiment — so the generation step works from evidence, not recollection. Grounding is the single most effective defense against hallucination.
Planning & task decomposition
Complex questions get broken into sub-tasks before any tool is called — the technique family that includes chain-of-thought reasoning and task decomposition. Ask elvaro to compare two assets against current sentiment, and the plan might be: fetch both prices → compute momentum indicators for each → pull the Fear & Greed reading → synthesize with your risk profile. You see this as the live progress stages while elvaro works.
Guardrails & structured output
Guardrails are constraints enforced outside the model: schemas that force outputs into a valid structure (a signal must contain entry, take-profit, and stop-loss — the format guarantees the discipline), validation that rejects malformed results, and policy rules the model cannot talk its way around. In elvaro, risk rules are guardrails, not suggestions: no signal ships without a stop-loss because the system won't emit one, regardless of what any model generates.
Observability, tracing & evals
Production agent systems are instrumented end to end: every agent run, tool call, and token is traced, so the full path from your question to the answer can be replayed and inspected. Evals — systematic test suites scoring answer quality, grounding, and safety — run continuously as models and prompts evolve. This is the unglamorous machinery that separates a reliable copilot from a demo that worked once.
Streaming & human-in-the-loop
Answers stream token-by-token with live progress events (fetching prices → running analysis → generating), so you're never staring at a spinner. And elvaro is deliberately human-in-the-loop: the agent researches, monitors, and recommends, but execution stays with you. In agent-design terms, elvaro has read-and-recommend autonomy, not act autonomy — a deliberate safety and trust choice, not a technical limitation.
Why this combination wins
Language in, discipline out. You talk to elvaro like a person; what comes back is built like a quant process — computed indicators, defined exits, confidence levels.
Each part covers the other's weakness. Analytics without language is a wall of numbers most people won't read. Language without analytics is confident storytelling. Together they're an analyst.
Auditability. Because facts come from tools, every claim in an answer traces back to a data source — not to "the model felt like it."