One governed runtime. Every app inherits it.
Frontline isn't a chatbot builder. It's a fixed, governed runtime — knowledge grounding, policy enforcement, human approval, and signed Trust Receipts. The Architect only writes configuration; the runtime does the rest, safely.
- Intent detected
- Grounded in approved knowledge
- Policy: pricing → human review
- Human approval
- Grounded answer sent
- Trust Receipt minted
The Architect builds it. The runtime governs it.
A clean split: describe-time generates configuration; run-time enforces it. The moat isn't the generator — it's the fixed, governed runtime everything runs on.
The Architect
Turns a plain-English workflow into configuration — data model, agents, policies, and workflows. It never writes arbitrary server code, so nothing it ships can escape the runtime.
- Plain-English → compiled manifest
- Generates config, not code
- Local-model cascade keeps it cheap
The governed runtime
Executes that configuration under enforcement — grounding answers, gating risk to humans, enforcing row-level access, and signing a Trust Receipt for every action.
- Grounding, policy & approval enforced
- Row-level access by default
- Signed receipt per action
Eight modules. Composed into every vertical.
Not features you wire up per app — the fixed foundation the Architect configures, so every generated app is grounded, governed, and auditable from day one.
Agent Runtime
Specialized agents — intent, knowledge answering, capture, validation, summarization, and tool execution. Each with its own prompt, tools, and policies.
- Per-agent prompts and tools
- Confidence thresholds
- Fallback and handoff rules
Agentic Workflows
Bounded, resumable multi-step execution with retries, durable state, branching, approval gates, and per-step checkpointing.
- Durable state machines
- Approval gates between steps
- Crash-safe checkpointing
Knowledge Engine
Hybrid retrieval + rerank over approved-only sources. Versioned, scoped per app, refreshed on demand.
- Document, FAQ, and policy collections
- Per-app knowledge scopes
- Source attribution on every answer
Policy Engine
Configurable guardrails: block, escalate, or require approval per topic, intent, or action — fail-closed by design.
- Topic and intent guardrails
- Action-level approval policies
- Risk categorization
Human Approval
Route low-confidence answers and high-risk actions to human reviewers with full context before anything irreversible runs.
- Approval inbox per role
- Inline source preview
- SLA tracking
Trust Receipts & Audit
Every AI run emits a signed, independently verifiable receipt — sources, prompts, model versions, policy triggers, and tool calls.
- Per-message evidence trail
- Signed & verifiable
- Exportable audit log
Tool & MCP Connectors
Governed tool calling into CRMs, email, WhatsApp, calendars, sheets, ERPs, webhooks, and MCP servers — every call logged.
- Webhook + REST connectors
- MCP server support
- Scoped, logged tool calls
App Configuration
Each app declares its data model, intents, capture fields, workflows, policies, and UI — as configuration, never a fork.
- Per-app schema & entities
- Templated agent sets
- Reusable across customers
Safety isn't a setting you can forget to turn on.
Because apps are configuration on a fixed runtime — not arbitrary code — grounding, policy, approval, and audit apply to every app by default. There's no path around them.
Config, not code
Generated apps can't bypass the runtime — there's no server code to escape into.
Enforced, not advised
Policies and approvals are checked at the write boundary, fail-closed.
Provable, not claimed
Every action leaves a signed receipt you can verify independently.