Workspace Architect
Describe your business. We build therest.
Start a setup session from your dashboard, pick a recipe for a faster path, and watch as bots, prompts, and guardrails are generated and validated for your domain.
A conversation, not a form
No 10-page dashboard crawl. Describe your business; the Architect asks what it needs, skips what it already knows, and builds what you approve.
Everything, all at once
Bots, prompts, KB, connectors, guardrails, automations, keys, team invites - created together, cross-references validated, nothing orphaned.
Edit later, in plain English
Change any bot with a sentence. Every edit becomes a Smart Diff you review before it applies - with atomic rollback on every session.
How it works
Interview. Compile. Blueprint. Review. Execute. Validate. Teach.
Every Architect session runs the same seven-stage pipeline - you always see what it knows, what it will write, and what it just did.
Conversation → Blueprint
interview · reason · synthesizePrompt
KB sources
Tools
Stages
Tests
Gates
Interview
Conversational discovery across 7 domains
The Architect asks 2–3 questions per turn across seven domains - business context, workflows, policies, integrations, knowledge, safety, and operations. It pre-fills from your Org Profile so it never asks the same question twice across bots.
How it works
- Domain-aware question flow - adapts to what you just said
- Skips any field already in your Org Profile (industry, compliance, brand voice)
- Supports partial scope: “just bots and prompts for now, KB later”
- Session auto-saves every message - close and resume days later
Compile
Structured extraction with provenance
Natural language gets turned into a typed requirement set. Every field is tagged with its source (user-stated, org-profile, template-default, inferred) and a confidence score, so you can see exactly where each decision came from.
How it works
- RequirementSet mapped 1:1 to Rylvo’s TypeScript schema - no freeform output
- Per-field provenance + confidence + source message
- Assumptions surfaced explicitly - no silent inferences
- Gaps listed with severity (blocking / recommended / optional)
Blueprint
A complete plan before a single write
The Architect generates a full Configuration Blueprint: every bot, prompt, connector, guardrail, KB source, schedule, channel, and API key it will create - with cross-references validated and confidence scored per item.
How it works
- Industry template as a starting point - customer answers override
- Cross-reference validation (every promptRef/botId resolves)
- Confidence score per item - low scores flagged for human review
- Each item shows what requirement it was derived from
Review
Per-item approve / edit / reject
The plan is shown as a tabbed view - Bots, Prompts, KB, Connectors, Guardrails, Automation, Team, Billing. Every card can be approved, edited, or rejected individually. Assumptions get confirmed separately before execution.
How it works
- Tabbed visualization - filter by resource type
- Dry-run mode - see exactly what will be written without creating
- Assumption confirmation panel - approve or revise each inference
- Smart Diff view for edits to existing resources
Execute
One resource at a time, with live links
The executor creates resources progressively - one at a time, in dependency order. After each creation you get a card with a direct dashboard link so you can inspect it before the Architect moves on.
How it works
- Dependency-ordered creation (bots → prompts → KB → connectors → guardrails → …)
- Live progress panel - done / creating / pending
- Every resource gets a clickable dashboard link
- Atomic rollback - one click undoes the whole session
Validate
One-click test + readiness scoring
After execution, the Architect verifies every doc exists in Firestore, resolves all cross-references, sends a sample conversation through the bot’s real API, and calculates a Bot Readiness Score (0–100%) with weighted breakdown.
How it works
- Post-creation integrity check (all IDs resolve)
- One-click smoke test - sends a real conversation through your API
- Bot Readiness Score: prompts, KB, guardrails, API keys, automation
- Warnings surfaced with direct fix-it links
Teach
Custom usage guide, not generic docs
Once the bot is live, the Architect writes a markdown guide specific to your configuration - how to test it, where its guardrails live, what each prompt controls, and how to tune every piece. Not generic documentation - your setup’s manual.
How it works
- curl example pre-filled with your real API key
- Per-guardrail explanations: what triggers it, where to edit
- Direct links to Traces, Edge Cases, Analytics
- Guided Tour mode highlights each created resource in the dashboard
What it builds
Twelve resource types - wired together, not scattered.
Everything a Rylvo workspace needs to go live. The Architect generates them in dependency order so cross-references resolve on the first write.
What the Architect actually creates
12 resource typesBots
Named agents with workflows, avatars, and status wiring.
Prompts
8 agent categories - composer, classifier, verifier, retrieval, and more.
Knowledge Base
Sources, blueprints, and bot-aware KB connections with sync schedules.
Connectors
Tool, state-sync, and event connectors with auth + endpoint configs.
Guardrails
PII, policy, output-filter, and escalation rules with action severity.
Edge Cases
Seed edge-case entries derived from stated worries and failure modes.
Scheduled Tasks
Trace scans, red-team runs, refresh jobs - wired to bots and channels.
Notifications
Slack, email, webhook, Discord, and Teams channels per bot.
Reports
Automated report configs with cadence, metrics, and recipients.
API Keys
Per-bot, per-environment keys with permission scopes.
Team Invites
Role-based invitations (admin, operator, viewer) sent at setup.
Billing Config
Low-balance thresholds and plan recommendations from expected volume.
Under every bot
Eight specialist agents, one coherent bot.
The Architect doesn’t write a single mega-prompt. It writes a pipeline - response composer, stage classifier, action selector, verifier, retrieval - each with its own prompt, policy, and tools. For larger orchestrations, it wires bots into groups that hand off cleanly.
Multi-agent orchestration
8 agent roles · per botEvery bot the Architect creates is itself a small multi-agent pipeline - a specialized prompt for each stage of a turn. The Architect writes all of them together so they share context, policies, and brand voice.
Response Composer
Generates the final response to the end user.
Stage Classifier
Determines the current workflow stage.
Action Selector
Chooses the next action or tool call to execute.
Escalation Classifier
Decides whether to hand off to a human operator.
Session Summarizer
Summarizes conversation history for long-term memory.
Verifier
Validates outputs against policy and schema before release.
Retrieval
Guides knowledge-base search, ranking, and citation.
Custom
Bring-your-own prompt for specialized sub-agents.
Response Composer
Generates the final response to the end user.
Stage Classifier
Determines the current workflow stage.
Action Selector
Chooses the next action or tool call to execute.
Escalation Classifier
Decides whether to hand off to a human operator.
Session Summarizer
Summarizes conversation history for long-term memory.
Verifier
Validates outputs against policy and schema before release.
Retrieval
Guides knowledge-base search, ranking, and citation.
Custom
Bring-your-own prompt for specialized sub-agents.
Agent Groups - bots that call other bots
For larger workflows, the Architect can create agent groups: a triage bot that routes to specialist bots (support, billing, legal, etc.), sharing guardrails and knowledge, with the right handoffs wired up automatically. The group appears on its own orchestration page with a graph view of who hands off to whom.
The interview
Seven domains, adaptive questions, zero repetition.
Every question is tagged to a domain and a requirement field. When a field is already in your Org Profile, the Architect skips it and tells you so.
The seven interview domains
hard + soft requirementsBusiness Context
Industry, compliance frameworks, company description, customer type, primary use case.
Workflow Design
Stages, required fields per stage, available actions, escalation triggers.
Policies & Rules
Prohibited behaviors, mandatory behaviors, brand voice, data restrictions.
Integrations
External systems, read/write permissions, auth methods, tool actions.
Knowledge Base
Sources, locations, change frequency, citation policy, bot assignments.
Quality & Safety
Primary concerns, edge cases, uncertainty policy, red-team toggle.
Operations
Team access, report cadence, notification channels, alert triggers.
After go-live
Edit any bot with a sentence.
Natural-language edits go through the same Blueprint → Review loop as the initial setup. You always see the exact before/after before anything changes.
Natural Language Edit - Smart Diff preview
awaiting approvalBEFORE
type: "pii_detection"
severity: "warn"
conditions: [
{ field: "output",
pattern: "SSN" }
]AFTER
type: "pii_detection"
severity: "block"
conditions: [
{ field: "output",
pattern: "SSN" },
+ { field: "output",
+ pattern: "credit_card" }
]Cross-session intelligence - the second bot is 5× faster.
Org-level answers (industry, compliance, brand voice, escalation policy, notification defaults) are saved once to your Org Profile. Every subsequent setup reads that profile, skips known questions, and focuses entirely on what makes this bot different. Clone an existing bot and the Architect reuses prompts, KB links, connectors, and guardrails with one checkbox.
Typical setup times
First full enterprise setup
7 domains, full interview
Second bot in same org
org profile pre-fills most fields
Setup recipe (industry-template)
3–4 bot-specific questions
NL edit on existing bot
instruction → diff → approve
Why teams trust it
The Architect is opinionated, never silent.
Safeguards on by default
nothing silent · nothing destructiveCompleteness gate
Programmatic check - the Architect refuses to generate a plan until every hard requirement is answered.
Per-item approval
Every card in the blueprint can be approved, edited, or rejected individually before execution.
Assumption surfacing
Every inference is stated explicitly with derivation. You confirm assumptions - nothing is silent.
Smart Diff
Edits to existing resources show before/after side-by-side with highlighted changes.
Atomic rollback
Every session is reversible. One click undoes all resources in reverse dependency order.
Full audit trail
Every decision is logged with rationale, context snapshot, and user feedback.
Answers
What teams usually ask
Does the Architect ever write anything without my approval?
No. The Architect always produces a Blueprint first. Nothing is written to Firestore until you explicitly approve the plan. Even during progressive execution you can pause, inspect each created resource, and roll back the entire session with one click.
What if I only want to set up some things now and finish later?
Say so. The Architect supports partial scope - you can defer any of the seven domains (KB, integrations, operations, etc.) and the Bot Readiness Score will remind you what’s missing. Resume anytime from Session History and the Architect picks up exactly where it stopped.
How does it handle a second or third bot in the same org?
The first bot’s org-level answers (industry, compliance, brand voice, escalation policy, notification defaults) are saved to your Org Profile. For every subsequent bot, the Architect pre-fills those fields and jumps straight to bot-specific questions - typical second-bot setup is under 5 minutes.
Can I edit an existing bot with natural language?
Yes. Open any bot and describe the change - “add a PII guardrail that blocks SSN and credit card numbers” - and the Architect produces a Smart Diff preview showing the exact before/after config. Nothing applies until you approve the diff.
Does it really build multi-agent flows, or just single bots?
Both. A single bot is composed of up to eight specialized prompts (composer, classifier, verifier, retrieval, etc.) working as a sub-agent pipeline. For larger orchestrations you can group bots - a triage bot routing to domain-specific bots - and the Architect configures the handoffs, shared guardrails, and cross-bot KB wiring.
How much setup time does this actually save?
A full enterprise setup that used to require 10+ dashboard pages and dozens of forms typically runs in 15 minutes of conversation. Second bot in the same org: under 5 minutes. If you start from a Setup Recipe (healthcare, fintech, e-commerce, etc.), the Architect can be done in under 3 minutes.
Deep dive
Why an AI architect beats a stack of forms
Configuration is a conversation, not a checklist
The Architect interviews you across seven domains — purpose, audience, knowledge, tools, policy, escalation, measurement — and translates the answers into a runnable blueprint. You stop translating between product intent and dashboard fields, because the model does that translation for you in plain language.
Twelve resources, one coherent design
A real bot needs a prompt, KB sources, tools, stages, evidence rules, escalation triggers, tests, and guardrails — and they all have to agree. The Architect synthesizes them together so your stages reference your tools, your tests cover your stages, and your escalation paths reflect the policies you actually wrote.
Editable forever, never a black box
Every artifact the Architect produces is a normal Rylvo resource you can edit, version, and revert. The conversation is recorded; the rationale is annotated; the diff is reviewable. There's no “magic prompt” you can't inspect.
Production-ready, not a sandbox toy
The Architect ships tests, gates, and evidence rules alongside the prompt. The bot it gives you can be deployed, monitored, and audited from day one — not weeks of follow-up wiring after a flashy demo.
Ready to ship?
Describe your business. We’ll build the rest.
Start a setup session from your dashboard, pick a recipe for a faster path, or clone an existing bot. Every action is reversible, every change is diffed, every decision is logged.