Overview
The Core Engine is the reasoning runtime every LuMay agent runs on. It takes a request (spoken, typed, or an API call), retrieves relevant context, calls the configured LLM, dispatches any tool calls the model requests, and returns a response. It is provider-agnostic: the agent configuration, flow, and connectors don't change when you swap between OpenAI, Anthropic, or a compatible API.
For evaluation purposes, the useful distinction is between what the Core Engine does (reasoning, retrieval, structured output, tool dispatch) and what it depends on externally (the LLM provider's availability and quality, the connectors it calls, and the documents you've uploaded for retrieval).
Action branch (when tool call is emitted)
The green (core) nodes are the platform's protected value - every request routes through the same boundary.
Request Flow
- Context retrieval - relevant context is retrieved via RAG (vector search against uploaded documents).
- LLM reasoning - the input, retrieved context, conversation history, and system prompt are sent to the configured LLM, which produces a response or a tool call.
- Tool dispatch - a tool call is routed to the correct connector by tool name.
- Connector execution - the connector authenticates and calls the external API, returning a normalised result.
- Response generation - the LLM uses the connector result to generate the final response.
- Trace persistence - the exchange is recorded as a trace, alongside transcript, sentiment, and outcome.
Evaluation Considerations
| Question | What it depends on |
|---|---|
| What happens if the LLM provider is unavailable? | External - depends on your configured provider's SLA, not something the Core Engine changes. |
| How current is the retrieved context? | Depends on how recently the knowledge-base documents were uploaded; retrieval doesn't fetch live external data on its own. |
| Can outputs be forced into a specific format? | Yes - structured outputs force typed JSON/enum/field values rather than free text, for reliable downstream processing. |
| Is there a cost ceiling per agent? | Token-budget and latency caps are configurable per agent. |
| Does the engine fail over to a second provider automatically? | Automatic provider failover is on the product roadmap and not available as a built-in feature today. |
Illustrative Example
The following traces one request through the engine; it is illustrative, not a specific deployment.
An agent receives a support question. The engine retrieves the three most relevant passages from the uploaded knowledge base, sends them with the question to the configured LLM, and receives a structured-output response flagging whether the issue requires escalation. If escalation is flagged, the orchestration layer routes it to a human reviewer before any action is taken - the Core Engine itself does not decide whether to escalate on its own authority; it produces the signal that the orchestration layer acts on.
FAQ
Does the Core Engine guarantee response quality?
No - response quality depends on the retrieved context, the configured LLM, and the prompt/flow design. The engine provides the mechanism, not a quality guarantee.
Can we bring our own LLM deployment?
The engine is provider-agnostic across OpenAI, Anthropic, and compatible APIs; see Security & Governance for how provider configuration interacts with data handling.
What's the difference between the Core Engine and the Orchestration Engine?
The Core Engine reasons about a single request; the Orchestration Engine coordinates multi-step workflows, approvals, and retries around multiple Core Engine calls. See Orchestration Engine.
Is memory persistent across sessions?
Conversation history persists across turns within a session; long-term context is managed via the call session store, not an unbounded memory store.
Does it support multi-turn tool chaining?
Yes - a response can include a tool call, and the result of that call is fed back into the next reasoning step within the same request-response cycle.
Related
- Voice Engine - the voice-specific pipeline built on this engine
- Connectors & Adapters - the systems the engine dispatches tool calls to
- Architecture - where this engine sits in the six-layer stack
- UK AI Platform hub - all 8 component pages