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

Stable, additive contract

Functional domains

Agents, workflows, entities, knowledge, queues and more

SDK

@lunnoa/client

Typed, codegen from your workspace

Deployment

Self-hosted

Runs inside your own infrastructure

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.

Wave 1 Customer engagement

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

Wave 1 Operations

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

Wave 2 Operations

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

Wave 2 Integration

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

Wave 2 Internal enablement

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

Backlog Data operations

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

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 to application capability

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

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

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

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.