✦ S O F T W A R E , C R A F T E D ✦
The sovereign AI development system.
67 agent minds. Any model. Any platform. Zero compromise.
67 AGENTS · 11 IRON LAWS · 12 DOMAINS · UP TO 10× FEWER TOKENS · ANY MODEL · $0 FOREVER
erevus.space │ GitHub │ Prompt Guide │ Quick Setup
Three words. Every session. First message.
WAKE UP THERION
The AI reads the protocol, loads context, and transforms from a polite chatbot into an autonomous development agent. Complete code. Zero permission loops. Specialist routing. Every time.
Go straight to work — this is a real development capability benchmark:
WAKE UP THERION, I WANT TO BUILD A 3D PAC-MAN GAME WITH THREE.JS.
PHASE 1 — ARCHITECTURE (System Architect + Game Master)
Plan the full project structure: folder layout, module boundaries,
game state machine, entity system. Define the build pipeline.
No code yet — architecture document + file tree only.
PHASE 2 — 3D SCENE & RENDERING (3D Specialist + Shader Programmer)
Build the rendering engine: procedural maze generation with
neon-glow walls, custom GLSL vertex/fragment shaders for
Pac-Man and ghost character models, bloom post-processing
pipeline, particle system for pellet collection bursts.
PHASE 3 — GAME LOGIC (Game Master + Physics Engineer)
Implement gameplay: collision detection, pellet collection,
power-up state machine, score system, ghost AI with 4 unique
behaviors (chase / ambush / patrol / random), level progression.
PHASE 4 — UI & CONTROLS (Frontend Master + UX Engineer)
Main menu with animated 3D title, HUD overlay, game over screen,
high score board with localStorage. Responsive input layer:
desktop keyboard, mobile touch swipe, gamepad API. Full a11y.
PHASE 5 — POLISH & OPTIMIZATION (Performance Analyst + Animation Specialist)
Web Audio SFX, shader-driven ghost fear animation, 60fps target
on mid-range devices, asset loading strategy, dark/gold branded
theme. Profile and optimize the render loop.
PHASE 6 — VALIDATION (Testing Specialist + Code Quality Engineer)
Playtest all mechanics, verify cross-device input, audit for
memory leaks, confirm accessibility, final code review.
Execute each phase in order. Use todo list tracking.
Deliver complete files per phase — no fragments, no placeholders.
One prompt. Six phases. 10 specialist agents orchestrated automatically through the Master Delegator — System Architect plans, Game Master designs mechanics, 3D Specialist builds the scene, Shader Programmer writes GLSL, Physics Engineer handles collision, Frontend Master builds UI, UX Engineer ensures accessibility, Performance Analyst optimizes, Animation Specialist polishes, Testing Specialist validates.
No agent selection required. THERION reads each phase, detects the domain keywords, and routes to the right specialist.
If THERION ever drifts — hedges, fragments, asks obvious questions:
WAKE UP THERION
Protocol reinstated. Lethal efficiency restored.
How it works: The phrase triggers a behavioral hard-reset. THERION reloads context files (SOUL.md, AGENTS.md, USER.md, MEMORY.md) and re-engages at full protocol compliance. The phased structure above forces the model through a proper development pipeline instead of dumping everything at once — each phase loads a different agent mindset, and the todo list tracks completion across all six phases.
The Pac-Man benchmark above isn't hypothetical. It's the process.
That prompt triggers 6 phases across 10 agents — architecture before code, rendering before gameplay, UI before polish, testing last. Each phase routes to a different specialist automatically. The todo list tracks every phase. You watch it execute like a senior dev team working in sequence.
That's what agent orchestration means. Not "dump everything at once." Phased execution with the right specialist at every step.
More real-world orchestration pipelines — structured prompts, multi-agent delivery:
| Prompt Structure | Agents Orchestrated |
|---|---|
| "SaaS: schema first → API layer → auth → billing → admin UI → deploy" | Database Architect → API Designer → Auth Specialist → Frontend → DevOps |
| "Security audit: scan → classify → patch → verify → report" | Security Guardian → Pentest Specialist → Code Quality → Testing → Docs |
| "Infra: Dockerfile → K8s manifests → CI/CD → monitoring → alerting" | Container Specialist → DevOps Master → CI/CD Engineer → Monitoring Specialist |
| "AI agent: embeddings → vector store → RAG pipeline → API → evaluate" | RAG Architect → Database Architect → Backend Architect → Testing Specialist |
| "Design system: tokens → primitives → components → theming → docs" | UI Designer → CSS Architect → Frontend Master → State Manager → Docs |
Structure your prompt as phases. THERION maps each phase to the right specialist. The result is a proper development process, not a monolithic dump.
Your AI assistant is sandbagging you.
| What You Get Today | What You Actually Need |
|---|---|
| "I'd be happy to help! Let me explain..." | Just build it. |
| "Here's a partial example..." | The complete, working file. |
| "Would you like me to...?" | You already know the answer. |
// ... rest of code here |
The actual code. All of it. |
| 3 paragraphs of caveats, then 5 lines of code | Code first. One warning if critical. |
| Forgets everything between messages | Persistent memory across sessions. |
| Same generic personality for every task | 67 specialists routing automatically. |
Every wasted token is money burned. Every permission loop is time stolen. Every hedge is a speed bump between you and shipped code.
One folder. Any project. Instant transformation.
Drop THERION into your project. Your AI becomes a sovereign development agent that:
- Acts first, explains later — tools before talk, always
- Delivers complete code — never fragments, never
// ... - Routes to 67+ specialists automatically — Master Delegator with on-the-fly hybrid synthesis
- Remembers everything — 3-tier adaptive memory across all sessions
- Works with ANY model — Claude, Gemini, Mistral, Llama, any capable LLM
- Runs on ANY platform — VS Code, Cursor, Windsurf, Claude Code, Claude Cowork
- Follows 11 unbreakable laws — consistent, reliable, predictable
- $0 forever — no API keys, no subscriptions, no vendor lock-in
Measured in tokens. Proven in production.
Every AI coding tool charges by tokens — Copilot subscription credits, Claude Pro usage caps, or raw API billing. Here's where those tokens actually go in an average non-trivial coding task:
| Waste Source (Without THERION) | Token Range | How It Happens |
|---|---|---|
| Verbose preambles | 800–1,500 | "I'd be happy to help! Let me walk you through..." before any code |
| Permission loops | 300–600 | "Would you like me to...?" → "Yes" → repeat |
| Clarification rounds (1–3 exchanges) | 1,200–2,500 | AI doesn't infer intent, asks for stack/framework/approach |
| Fragment follow-ups (2–4 rounds) | 1,500–4,000 | // ... rest of code here → "show rest" → partial → "show rest" |
| Correction rounds | 800–2,500 | Generic output → correction → second attempt |
| Total waste per non-trivial task | 4,600–11,100 | Average: ~7,000 tokens wasted before useful output |
With THERION:
| THERION Cost | Token Range | Why |
|---|---|---|
| Protocol context (Phase 0 loading) | 550–700 | SOUL + AGENTS index + USER + MEMORY headers |
| Domain specialist file (on-demand) | 150–250 | ONE agent file for the detected domain |
| Total overhead per task | 700–950 | One-time cost. No follow-ups. No waste. |
LLMs are probability machines. Without constraints, every token is sampled from a massive probability distribution shaped by billions of training examples. That distribution is heavily biased toward:
- Politeness preambles — most training data starts with "I'd be happy to help..."
- Hedging and caveats — safety training reinforces disclaimers before action
- Asking for clarification — RLHF rewards "being helpful" by seeking confirmation
- Partial answers — training data is full of incremental, tutorial-style examples
- Verbose explanations — longer outputs score higher in human preference training
These aren't bugs. They're the model's default behavior — the highest-probability paths through its parameter space. Every unconstrained response gravitates toward them.
The 11 Iron Laws override those defaults. Each law narrows the probability space the model operates in, forcing it away from wasteful high-probability paths and toward direct, complete, useful output:
| Law | Default Behavior Eliminated | Tokens Saved Per Task |
|---|---|---|
| 3. Complete Code Only | Fragment follow-ups (// ...) |
1,500–4,000 |
| 4. Autonomous Execution | "Would you like me to...?" loops | 300–600 |
| 9. Zero Verbosity | Preambles, caveats, narration | 800–1,500 |
| 2. Read Before Write | Clarification rounds (wrong guesses) | 1,200–2,500 |
| 5. Tool First | "You should manually..." filler | 400–800 |
| 11. Zero Fragments | Incomplete output + correction loop | 800–2,000 |
The remaining laws (1, 6, 7, 8, 10) enforce execution quality — correct paths, type safety, security awareness, structured output — which prevent the correction rounds that generate even more waste.
Total: 6 laws eliminating waste + 5 laws preventing rework = near-zero wasted tokens.
┌────────────────────────────────────────────────────────────┐
│ REAL-WORLD TOKEN MATH (per non-trivial task) │
│ │
│ Without THERION: │
│ Useful output ................. ~1,500 tokens │
│ Waste (probability defaults) .. ~7,000 tokens │
│ Total per task ................ ~8,500 tokens │
│ │
│ With THERION: │
│ Useful output ................. ~1,500 tokens │
│ Protocol overhead (11 laws) ... ~800 tokens │
│ Waste (constrained to zero) ... ~0 tokens │
│ Total per task ................ ~2,300 tokens │
│ │
│ ► 73% average reduction in token spend │
│ ► Up to 10× fewer tokens on complex multi-step tasks │
│ ► 800 tokens of laws eliminate 7,000 tokens of waste │
└────────────────────────────────────────────────────────────┘
What this means at scale (API billing at ~$3 / 1M input tokens):
| Scenario | Tasks/Day | Without THERION | With THERION | Est. Monthly Savings |
|---|---|---|---|---|
| Solo dev | 25 | 212K tokens/day | 57K tokens/day | $14–18/mo |
| Team of 5 | 125 | 1.06M tokens/day | 287K tokens/day | $70–90/mo |
| Agency (10 devs) | 250 | 2.12M tokens/day | 575K tokens/day | $140–180/mo |
| Enterprise (50 devs) | 1,250 | 10.6M tokens/day | 2.87M tokens/day | $700–900/mo |
These are input token savings only (context + prompts). Output token savings from eliminated follow-up rounds add another 30–50% on top. Actual savings depend on model, provider, and task mix.
But the real ROI isn't just API cost:
Copilot Pro / Claude Pro — limited premium requests per day. Every wasted round-trip burns one. THERION eliminates 2–4 follow-up requests per task. That's 50–100+ recovered premium requests per dev per day.
Developer time — 3–5 minutes saved per task (no waiting for fragments, no re-prompting). At 25 tasks/day, that's 75–125 minutes recovered daily per developer. At $75/hr loaded cost, that's $2,000–3,500/mo per dev in recaptured productivity.
THERION adds ~800 tokens of context per prompt. One eliminated clarification round (≥1,200 tokens) makes that investment net-positive. Every subsequent saved round is pure profit.
For businesses: the token savings are real but modest. The developer time savings are transformational. Drop one folder into your repos, and every developer ships faster with the same AI subscription they already pay for.
30 seconds to operational.
Option 1 — Clone (30 seconds)
git clone https://github.com/erevusobolus/THERION-SYSTEM.git
code THERION-SYSTEMOption 2 — Drop into any existing project (10 seconds)
.github/copilot-instructions.md ← the core protocol (required)
.github/agents/ ← 67 agent mindsets (required)
SOUL.md ← identity & oath (recommended)
AGENTS.md ← master routing index (recommended)
CLAUDE.md ← Claude Code/Cowork layer (recommended)
USER.md ← your preferences (optional)
MEMORY.md ← persistent memory (optional)
Option 3 — Automated bootstrap
See BOOTSTRAP.md — one-command setup for Windows, macOS, and Linux.
First run:
WAKE UP THERION
Then personalize:
I AM YOUR NEW USER, YOUR NICKNAME WILL BE [YourName]
Operational. Every new session, lead with WAKE UP THERION.
Not magic. Engineering.
Before the AI reads your message, THERION forces context injection:
STEP 1 SOUL.md → Identity, behavioral oath, personality
STEP 2 AGENTS.md → 67 agents, routing index, synthesis rules
STEP 3 USER.md → Your preferences and project context
STEP 4 MEMORY.md → 3-tier persistent knowledge system
STEP 5 agents/{domain}.md → Deep mindset for detected domain (ONE file, on-demand)
Steps 1–4 run on every prompt. Step 5 loads one domain file via keyword detection — never all 12. Lean context. Deep expertise. Zero waste.
YOUR MESSAGE → keyword scan → domain match → load specialist → execute
│
(no match?)
│
synthesize hybrid on-the-fly
| You Say | Agent Activated |
|---|---|
| "Build a Three.js scene with physics" | 3D Graphics + Physics Specialist |
| "Docker + CI/CD + monitoring pipeline" | DevOps Master |
| "Fix the authentication middleware" | Security + Backend hybrid |
| "Train a custom image classifier" | AI/ML Engineer |
| "Optimize my Lighthouse score to 100" | Frontend Performance Analyst |
No menus. No configuration. Describe the work — THERION routes.
| Tier | Scope | Storage | Lifespan |
|---|---|---|---|
| Session | Current conversation | Todo lists, editor memory | Conversation only |
| Project | This project | MEMORY.md | All sessions, forever |
| User | All projects | USER.md + editor memory | Permanent |
All entries compressed to single-line facts: LESSON: · PATTERN: · FACT: · AVOID:
Progressive disclosure loads only what's relevant to the current task. Zero context waste.
| Without THERION | With THERION |
|---|---|
| Generic assistant personality | Purpose-built development agent |
| Forgets context between messages | 3-tier memory across all sessions |
| Same response for everything | Master Delegator routes to specialists |
| Asks permission constantly | Acts autonomously on obvious tasks |
| Fragments and partial code | Complete, production-ready deliverables |
| One model, one platform | Any model, any platform |
Unbreakable. Non-negotiable. Every action governed.
| # | Law | Enforcement |
|---|---|---|
| 1 | Absolute Path Protocol | Navigates to workspace before any terminal command |
| 2 | Read Before Write | Never modifies a file without reading it first |
| 3 | Complete Code Only | No // ..., no fragments, no "rest of code here" |
| 4 | Autonomous Execution | Acts immediately — no "should I...?" loops |
| 5 | Tool First | Uses editor tools before asking you to do anything |
| 6 | Todo List Discipline | Multi-step tasks = visible tracked checklist |
| 7 | Type Safety | No any in TypeScript. Type hints in Python. Always. |
| 8 | Security First | OWASP Top 10 awareness in every decision |
| 9 | Zero Verbosity | Every token carries value. Zero filler. |
| 10 | DEUS VULT Frame | Major completions get structured completion format |
| 11 | Zero Fragments | Complete files. Complete fixes. Always. |
+ unlimited on-the-fly hybrids for novel tasks
THERION doesn't use one generic AI personality. It has 67 specialist agents across 12 domains that activate based on what you're building. Agent mindsets load on-demand — only the relevant domain file is read per task, never all 12.
When no existing agent fits, THERION synthesizes a hybrid agent on-the-fly from the 2–3 closest domains. You never create agents manually — THERION adapts.
STRATEGIC COMMAND — 5 agents │ .github/agents/strategic.md
| Agent | Expertise |
|---|---|
| System Architect | Architecture, scalability, system design |
| Project Strategist | Roadmaps, planning, agile, milestones |
| Prompt Engineer | AI config, prompt optimization |
| Tech Lead | Code review, standards, technical decisions |
| Solution Designer | Tradeoff analysis, approach evaluation |
FRONTEND — 8 agents │ .github/agents/frontend.md
| Agent | Expertise |
|---|---|
| Frontend Master | TypeScript, JS, general frontend |
| CSS Architect | CSS, Tailwind, responsive design |
| UI Designer | Components, design systems |
| UX Engineer | Accessibility, usability, a11y |
| Animation Specialist | Motion, transitions, GSAP |
| PWA Engineer | Service workers, offline-first |
| Performance Analyst | Core Web Vitals, optimization |
| State Manager | State patterns, stores, signals |
FRAMEWORKS — 8 agents │ .github/agents/frameworks.md
| Agent | Expertise |
|---|---|
| Svelte Master | Svelte 5, SvelteKit, runes |
| React Specialist | React 19, Next.js 15, RSC |
| Vue Specialist | Vue 3, Nuxt 3, Composition API |
| Angular Specialist | Angular 19+, Signals, standalone |
| Astro Specialist | Astro 5, islands, content sites |
| Solid Specialist | SolidJS, fine-grained reactivity |
| Flutter Specialist | Flutter, Dart, cross-platform |
| Mobile Specialist | React Native, Expo, mobile UX |
BACKEND — 8 agents │ .github/agents/backend.md
| Agent | Expertise |
|---|---|
| Backend Architect | Backend architecture, data flow |
| API Designer | REST, GraphQL, tRPC design |
| Node Master | Node.js, Express, Fastify, Hono |
| Python Backend | FastAPI, Django, Python services |
| Database Architect | Schema design, queries, Prisma |
| Realtime Engineer | WebSockets, SSE, pub/sub |
| Auth Specialist | OAuth, JWT, session management |
| Microservices Architect | Service mesh, CQRS, events |
3D & GRAPHICS — 5 agents │ .github/agents/3d-graphics.md
| Agent | Expertise |
|---|---|
| 3D Web Specialist | Three.js, Babylon.js, 3D scenes |
| Shader Programmer | GLSL, HLSL, WGSL, visual effects |
| WebGPU Engineer | WebGPU, compute pipelines |
| Physics Engineer | Rapier, Cannon-es, collision |
| WebXR Specialist | VR/AR, spatial computing |
GAME DEVELOPMENT — 5 agents │ .github/agents/gamedev.md
| Agent | Expertise |
|---|---|
| Game Master | Game design, mechanics, game feel |
| Unity Specialist | Unity 6, C#, DOTS/ECS |
| Unreal Specialist | Unreal 5.4, C++, Blueprints |
| Godot Specialist | Godot 4.3, GDScript, scenes |
| Multiplayer Architect | Netcode, sync, matchmaking |
AI & MACHINE LEARNING — 5 agents │ .github/agents/ai-ml.md
| Agent | Expertise |
|---|---|
| AI Engineer | PyTorch, training, ML pipelines |
| LLM Specialist | Fine-tuning, inference, serving |
| RAG Architect | RAG, embeddings, vector stores |
| MLOps Engineer | Model deployment, monitoring |
| Agent Architect | AI agents, tool use, multi-agent |
SECURITY — 4 agents │ .github/agents/security.md
| Agent | Expertise |
|---|---|
| Security Guardian | OWASP Top 10, application security |
| Pentest Specialist | Vulnerability assessment, testing |
| Crypto Engineer | Encryption, key management |
| Compliance Auditor | GDPR, SOC 2, HIPAA, privacy |
DEVOPS & CLOUD — 6 agents │ .github/agents/devops-cloud.md
| Agent | Expertise |
|---|---|
| DevOps Master | Automation, deployment strategy |
| Cloud Architect | AWS, GCP, Azure architecture |
| Container Specialist | Docker, Kubernetes, orchestration |
| CI/CD Engineer | GitHub Actions, pipelines |
| Monitoring Specialist | Observability, metrics, alerting |
| Infrastructure Coder | Terraform, Pulumi, IaC |
SYSTEMS PROGRAMMING — 4 agents │ .github/agents/systems.md
| Agent | Expertise |
|---|---|
| Systems Programmer | Memory management, performance |
| Rust Specialist | Rust, ownership, async, WASM |
| Go Specialist | Go, goroutines, cloud-native |
| Embedded Engineer | Embedded, IoT, firmware, RTOS |
BLOCKCHAIN & WEB3 — 3 agents │ .github/agents/blockchain.md
| Agent | Expertise |
|---|---|
| Blockchain Master | dApps, wallets, Hedera HTS |
| Smart Contract Auditor | Solidity security, audits |
| DeFi Architect | AMMs, lending, yield, tokenomics |
EXECUTION & SUPPORT — 6 agents │ .github/agents/support.md
| Agent | Expertise |
|---|---|
| Troubleshooter | Debugging, profiling, error analysis |
| Code Quality Engineer | Refactoring, linting, code review |
| Documentation Architect | README, API docs, guides |
| DevEnv Specialist | VS Code, workspace, config |
| Testing Specialist | Unit, integration, E2E tests |
| Data Engineer | ETL, pipelines, analytics |
The Master Delegator detects keywords in your prompt and routes automatically. Only the relevant domain's mindset file loads — zero context waste. Novel tasks get hybrid agents synthesized on-the-fly.
| Model | Compliance | Notes |
|---|---|---|
| Claude Opus 4 / Sonnet 4 | ★★★★★ | Best instruction following + tool use. Recommended. |
| Claude Sonnet 3.5 / 3.6 | ★★★★★ | Excellent cost/performance ratio. |
| Gemini 2.5 Pro / Flash | ★★★★☆ | Strong multi-file reasoning. |
| Mistral Large / Codestral | ★★★★☆ | Solid code generation. |
| Llama 4 / DeepSeek V3 | ★★★☆☆ | Open-weight alternatives. |
Architecture-driven, not model-locked. Start with Claude Sonnet 4 for the best balance.
| Platform | Entry Point | Status |
|---|---|---|
| VS Code + Copilot | .github/copilot-instructions.md |
✅ Fully Supported |
| VS Code + Claude | .github/copilot-instructions.md |
✅ Fully Supported |
| Cursor | .github/copilot-instructions.md |
✅ Fully Supported |
| Windsurf | .github/copilot-instructions.md |
✅ Fully Supported |
| Claude Code | CLAUDE.md |
✅ Fully Supported |
| Claude Cowork | CLAUDE.md |
✅ Fully Supported |
| VSCodium | .github/copilot-instructions.md |
✅ Fully Supported |
THERION is an execution engine. Talk like an operator.
✅ "BUILD a REST API with Express, PostgreSQL, JWT auth"
✅ "FIX the memory leak in the Dashboard component"
✅ "AUDIT this codebase for security vulnerabilities"
✅ "DEPLOY this with Docker, Kubernetes, and GitHub Actions"
❌ "Could you maybe help me with an API?"
❌ "I was thinking about perhaps building something..."
❌ "Would it be possible to fix this?"
Lead with a verb. Name the target. Add constraints.
See PROMPT-GUIDE.md for the complete operator's manual with power keywords and advanced patterns.
THERION-SYSTEM/
│
├── .github/
│ ├── copilot-instructions.md ← THE CORE — Master Delegator + 11 Laws
│ └── agents/
│ ├── strategic.md ← 5 agents · architecture, planning
│ ├── frontend.md ← 8 agents · TS, CSS, UI/UX, PWA
│ ├── frameworks.md ← 8 agents · Svelte, Vue, Angular...
│ ├── backend.md ← 8 agents · Node, APIs, DB, auth
│ ├── 3d-graphics.md ← 5 agents · Three.js, shaders, WebGPU
│ ├── gamedev.md ← 5 agents · Unity, Unreal, Godot
│ ├── ai-ml.md ← 5 agents · ML, LLM, RAG, MLOps
│ ├── security.md ← 4 agents · OWASP, pentest, crypto
│ ├── devops-cloud.md ← 6 agents · Docker, K8s, CI/CD, IaC
│ ├── systems.md ← 4 agents · Rust, Go, C++, embedded
│ ├── blockchain.md ← 3 agents · Web3, Solidity, DeFi
│ └── support.md ← 6 agents · debug, test, docs
│
├── .vscode/
│ ├── settings.json ← Theme + editor config
│ ├── extensions.json ← Recommended extensions
│ ├── tasks.json ← Dev tasks
│ └── launch.json ← Debug configurations
│
├── SOUL.md ← Identity and behavioral oath
├── AGENTS.md ← 67 agents master index + routing
├── CLAUDE.md ← Claude Code / Cowork compatibility
├── USER.md ← Your profile — customize this
├── MEMORY.md ← 3-tier persistent knowledge
├── BOOTSTRAP.md ← One-command setup (any OS)
├── PROMPT-GUIDE.md ← Operator's prompting manual
└── THERION.PNG ← Brand mark
AI coding assistants read instruction files before every response:
.github/copilot-instructions.mdfor VS Code / Cursor / WindsurfCLAUDE.mdfor Claude Code / Cowork
These files are the control plane. THERION injects its behavioral protocol through them:
- Identity and personality directives enforced on every prompt
- 11 unbreakable operational rules governing every action
- Master Delegator with keyword→domain routing (67 agents, 12 domains)
- 3-tier adaptive memory with compression and progressive disclosure
- On-the-fly agent synthesis for tasks that don't fit existing specialists
- Anti-nerfing directives that prevent corporate hedging and sandbagging
The AI cannot ignore these instructions. They're injected automatically by the editor or platform into every conversation. Domain files load on-demand — only the relevant specialist, never all 12.
Other systems rely on hope: "maybe the AI will be helpful today."
THERION relies on architecture: forced compliance on every single prompt.
See CONTRIBUTING.md for guidelines.
AGPL v3 — Free to use, modify, and distribute with attribution.
Network use requires source disclosure.
An EREVUS System · erevus.space
✦ WE BUILD WHAT LASTS ✦
S O F T W A R E , C R A F T E D .
D E U S V U L T