Customer-facing copilot
Embed a Lunnoa agent directly inside your own product or support desk, with streaming replies, per-user history, and tools scoped to your CRM and product data.
- Impact
- —
- Effort
- M
- TTV
- 4 to 6 weeks
Section 01
Executive summary
Lunnoa Automate runs as a headless platform layer behind your own applications. Your team owns the interface, the design system, the identity model, and the business rules, while Lunnoa's Public API supplies the agent runtime, automation engine, structured data layer, and knowledge base underneath.
Public API operations
86
Stable, additive contract
Functional domains
9
Agents, workflows, entities, knowledge, queues and more
SDK
@lunnoa/client
Typed, codegen from your workspace
Deployment
Self-hosted
Runs inside your own infrastructure
Section 02
What you can build
Each domain below is a set of building blocks. Combined, they let your team ship purpose-built internal applications instead of adopting a fixed front end.
Exception and review queue
Build a review inbox on top of Lunnoa queues, so exceptions flagged by a workflow land directly in front of the right person, with full retry and error history.
- Impact
- —
- Effort
- S
- TTV
- 3 to 4 weeks
Client onboarding portal
Model each onboarding case as a typed entity with a state machine, so your portal renders forms and status buttons straight from the schema.
- Impact
- —
- Effort
- M
- TTV
- 6 to 8 weeks
System event triggers
Let internal systems call a Lunnoa webhook to start a workflow, and resume paused steps from a custom approval form when human input is needed.
- Impact
- —
- Effort
- S
- TTV
- 2 to 3 weeks
Policy and product knowledge assistant
Ingest policy documents and product sheets into a Lunnoa knowledge base, then attach it to any agent your teams build.
- Impact
- —
- Effort
- M
- TTV
- 4 to 6 weeks
Structured data workbench
Use context blueprints to pull deterministic, multi-source context for each record, so an agent gives your team one call instead of several separate lookups.
- Impact
- —
- Effort
- L
- TTV
- 8 to 12 weeks
Section 03
Platform capabilities, mapped to what they enable
The Public API is organised into nine domains. Each one is a layer you can build directly on, without reverse engineering the bundled app.
| Platform layer | What it enables you to build |
|---|---|
| Developer platform | Typed portals, review tools, and chat interfaces via @lunnoa/client codegen and a stable REST contract |
| Agent runtime | Branded copilots and support assistants inside your own apps, with streaming replies and per-user task history |
| Automation engine | Workflow triggers from your own systems, human-readable progress tracking, and resumable approval steps |
| Structured data (Objects) | Typed business records such as cases, deals, and clients, with schemas, state machines, and full state history |
| Knowledge (RAG) | Ingestion pipelines that feed policy and product documents into agent-accessible knowledge bases |
| Human-in-the-loop queues | Exception and review inboxes wired directly to workflow executions, with retry and error tracking |
| Integrations | Programmatic connections to internal systems, discoverable through a single app catalogue |
| Workspace configuration | Multi-project structuring and shared variables across teams and environments |
| Identity and access | SSO through your existing identity provider, just-in-time provisioning, and grant-based agent sharing |
Section 04
Why this fits data-sensitive environments
Key findingHigh impact
Self-hosted means the platform runs inside your perimeter
Lunnoa Automate deploys inside your own infrastructure. Data stays inside your boundary, and the identity layer connects to your existing identity provider rather than creating a parallel user store.
Building agent and workflow infrastructure from scratch
- Design and operate your own LLM orchestration, streaming, and conversation storage
- Build a workflow engine with retries, human-in-the-loop steps, and execution tracking
- Stand up a schema and state machine layer for every new record type
- Build SSO, RBAC, and per-user access from the ground up
Building on Lunnoa's headless layer
- Call agentChat and executions from a typed SDK, focused entirely on your interface
- Trigger and track workflows through executionPath, without owning the engine
- Model entities against an existing attributeSchema and stateSchema
- Connect your identity provider once; grant-based agent sharing follows automatically
Section 05
Getting started
A phased path onto the headless layer
Phase 1: Connect
Week 1- Provision a workspace API key
- Run codegen against your workspace
- Stand up one proof of concept against a single agent or workflow
Phase 2: Add identity
Weeks 2 to 3- Connect your existing identity provider through OIDC SSO
- Enable just-in-time provisioning for the pilot user group
- Move the proof of concept to per-user history
Phase 3: Expand
Weeks 4 to 8- Add entities for the relevant record types
- Ingest knowledge sources for the same use case
- Wire a queue for exceptions and reviews
Phase 4: Operate
Ongoing- Add projects and variables as more teams build on the workspace
- Extend agent shares as adoption grows
Section 06
Next steps
RecommendationDo nowEffort: SOwner: Your engineering team + Lunnoa
Scope a proof of concept behind one workflow or agent
Pick the use case with the clearest owner and the smallest data surface, most likely an exception review queue or a single agent copilot, and build it against the Public API in the coming weeks.
RecommendationDo nextEffort: MOwner: Your IT team
Pilot SSO with your existing identity provider for a pilot group
Once the proof of concept is live, move it from a server-held API key to per-user JWTs, so each pilot user gets their own history and only the agents shared with them.
RecommendationLaterEffort: MOwner: Your teams + Lunnoa
Open the workspace to additional teams
Use projects and variables to give each team its own space on the same workspace, without duplicating infrastructure.