Blueprints
Describe once, generate everything. Blueprints are the specification layer that turns declarative YAML into production-ready APIs, authentication, real-time messaging, AI integration, webhooks, workflows, and full-stack applications — in any language, on any platform, with zero dependencies.
Why Blueprints?
Every tool in the market solves a fragment of the problem. Automation platforms wire together existing APIs. AI code generators produce throwaway prototypes. UI builders generate frontend components without backend contracts. None of them give you a complete, persistent, specification-driven system that you own entirely.
Blueprints are the missing layer: the specification that sits between what you want and what gets built. They encode security models, API contracts, data schemas, and operational behaviour as structured documents — consumed by humans, LLMs, and CI/CD pipelines alike. Nothing operates in the Weblisk framework without a schema-compliant blueprint. If a schema doesn't define it, the framework doesn't allow it.
Full-Stack Specification
Not just UI. Not just automation. Blueprints cover APIs, auth, data, real-time, AI, webhooks, governance, monitoring, and deployment — the complete application surface.
Generate Any Language
One spec → Go, Node.js, Rust, or Cloudflare Workers. Same blueprint, different platform bindings. Switch languages without rewriting specifications.
AI-Native Code Generation
Blueprints are designed to be consumed by LLMs. The CLI dispatches specs to your configured AI provider and validates the output — deterministic, reproducible, verifiable.
You Own Everything
No vendor lock-in. No SaaS dependency. Generated code is yours — plain files in your repo, deployed on your infrastructure, with zero runtime dependencies on Weblisk.
The Paradigm Shift
Traditional development asks you to write the same patterns over and over: set up auth, wire CRUD endpoints, configure webhooks, add rate limiting, handle retries, implement caching. Every project starts from scratch or bolts together leaky abstractions.
Blueprint-driven development inverts this: declare the contract, generate the implementation. The specification is the source of truth — code is a build artifact that can be regenerated, upgraded, or ported to a new platform without losing the design intent.
# Generate a complete project from blueprints weblisk generate --platform go # Create a new domain with AI, auth, and real-time weblisk domain create chat --patterns api-ai,auth-token,realtime-chat # Validate all blueprints against schemas weblisk validate # Update to latest specifications from all sources weblisk blueprints update
What Blueprints Cover
82 specifications organized into six categories — every layer of a production system:
| Category | Purpose | Count |
|---|---|---|
| Protocol | Wire protocol — endpoints, Ed25519 identity, canonical types, federation | 4 |
| Architecture | System components — orchestrator, domains, agents, gateway, admin, client, observability, security | 16 |
| Patterns | Cross-cutting contracts — API, auth, governance, infrastructure, workflows, operations | 38 |
| Agents | Infrastructure agents — workflow, task dispatch, lifecycle, alerting, health, sync, cron | 11 |
| Platforms | Implementation bindings — Go, Cloudflare Workers, Node.js, Rust | 4 |
| Standards | Project conventions — structure, global config, code gen, theme, pages, components, islands | 9 |
How It Compares
Weblisk blueprints occupy a unique position — they are the specification platform that generates what other tools only partially address:
| Capability | Automation Tools | AI Code Generators | UI Builders | Weblisk Blueprints |
|---|---|---|---|---|
| API design & generation | — | Partial | — | Full spec → code |
| Authentication & security | — | Ad-hoc | — | Formal model |
| Real-time & messaging | Limited | Ad-hoc | — | Full spec → code |
| AI integration | Plugin | Itself | — | Multi-provider gateway |
| Governance & compliance | — | — | — | Built-in |
| Multi-language output | — | One at a time | — | Same spec, any platform |
| Persistent specification | Workflow JSON | None (ephemeral) | None | Versioned YAML/Markdown |
| Self-hosted / no vendor | Some | — | — | Always |
Architecture at a Glance
Hub (self-sovereign deployment) ├── Application Gateway (end-user edge security) │ ├── Session management, ABAC, rate limiting │ └── Route protection → agent mediation ├── Admin Gateway (operator access — separate network) │ └── Ed25519 auth, MFA, IP allowlist, 4-eyes approval ├── Orchestrator (trust anchor) │ ├── Registration, namespace control, service directory │ └── Domain Controllers (business logic directors) │ └── Work Agents (task executors) ├── Infrastructure Agents (system services) │ ├── Workflow, Task, Lifecycle, Alerting │ ├── Incident Response, Health Monitor, Hub │ └── Sync, Cron, Webhook, Email ├── Cross-Cutting Patterns (38 — inherited via extends) │ ├── Scope, Policy, Safety, Approval, Privacy │ ├── Contract, Governance, Security, Observability │ └── Workflow, Notification, Storage, Caching... └── Federation (hub-to-hub collaboration)
Zero-Dependency Philosophy
Blueprints enforce the Weblisk zero-dependency principle at every layer:
- Go — Standard library only. SQLite compiled into the binary.
- Rust — Minimal curated crates (tokio, hyper, serde). Single static binary per agent.
- Cloudflare — Platform-native APIs only (Workers KV, Durable Objects, Web Crypto).
- Node.js — Recommended libraries are choices, not requirements.
- AI models — The only layer with external dependencies. Local models (Ollama) are the default.