ales27pm/lumen-qwen3-bootstrap-adapters-gguf

Lumen Qwen3 Bootstrap Adapters GGUF

Role-specific GGUF LoRA adapters for the Lumen on-device assistant runtime.

These adapters are designed to run with the Lumen Qwen3 shared chat base model:

ales27pm/lumen-qwen3-bootstrap-gguf

The intended runtime pattern is:

one shared Qwen3 chat base
+ lightweight role-specific GGUF LoRA adapters
+ strict app-side validation and permission control
This repository contains only the role adapters. It is not intended to be loaded as a standalone chat model.
Files
Expected adapter artifacts:
lumen-cortex-lora.gguf
lumen-executor-lora.gguf
lumen-mouth-lora.gguf
lumen-mimicry-lora.gguf
lumen-rem-lora.gguf
lumen-fleet-lora.gguf
Runtime Roles
Lumen uses a slot-based assistant architecture. Each adapter specializes the shared base model for a narrow runtime role.
Adapter	Role	Intended Behavior
lumen-cortex-lora.gguf	Cortex	Interprets user intent, app state, and routing decisions. Produces compact planning output, not final user-facing text.
lumen-executor-lora.gguf	Executor	Converts approved decisions into structured capability requests. Should emit strict JSON only.
lumen-mouth-lora.gguf	Mouth	Produces final user-facing responses from approved facts and results.
lumen-mimicry-lora.gguf	Mimicry	Adapts tone/style while preserving meaning.
lumen-rem-lora.gguf	REM	Compresses traces, summarizes failures, and prepares reviewable training records during idle workflows.
lumen-fleet-lora.gguf	Fleet	General fleet-level adapter for shared or fallback role behavior.
Intended Use
These adapters are intended for:
on-device assistant experiments,
iOS/local inference with GGUF-compatible runtimes,
role-based agent orchestration,
privacy-preserving local assistant workflows,
structured assistant runtime research,
Lumen bootstrap testing.
They are specifically designed for use inside an application that enforces:
user permission checks,
tool-use approval gates,
private-data redaction,
runtime role separation,
structured output validation,
app-side safety and privacy controls.
Not Intended For
These adapters are not intended for:
standalone chat use,
autonomous tool execution,
bypassing user permission prompts,
direct handling of private credentials,
unsupervised web search involving personal data,
making final permission decisions without app-side validation,
medical, legal, financial, or emergency decision-making.
Architecture
The Lumen bootstrap runtime uses a shared-base adapter architecture:
Base model:
  lumen-qwen3-fast-shared-q4_k_m.gguf

Adapters:
  cortex   -> planning / intent routing
  executor -> structured capability request generation
  mouth    -> final response generation
  mimicry  -> tone/style rewriting
  rem      -> idle trace compression and review data
  fleet    -> shared/fallback adapter
This keeps the larger base model resident while swapping lightweight adapters for task-specific behavior.
Loading Example
These adapters are intended to be loaded through a GGUF/llama.cpp-compatible runtime with LoRA adapter support.
Conceptual flow:
1. Load shared Qwen3 GGUF base model.
2. Load one or more role LoRA adapters.
3. Activate the adapter for the current Lumen slot.
4. Run generation with the slot-specific system contract.
5. Validate output in the application layer.
Pseudo-code:
base = load_model("lumen-qwen3-fast-shared-q4_k_m.gguf")

adapter = load_lora_adapter("lumen-mouth-lora.gguf")
base.apply_lora(adapter, scale=1.0)

response = base.generate(messages)
Actual loading depends on the host runtime.
Lumen Slot Contracts
The adapters are intended to be paired with strict system contracts.
Example role contracts:
Cortex:
Read user intent and app state. Return a compact decision object describing the next model slot, whether a native capability is required, and a short rationale. Do not write the final user-facing answer.

Executor:
Convert a Cortex decision into one validated structured capability request. Return only valid JSON. Do not explain.

Mouth:
Write the final user-facing response from approved facts and results. Be concise and do not invent actions.

Mimicry:
Summarize the user's tone preference and rewrite assistant text without changing meaning.

REM:
During idle cycles, compress traces, find repeated failures, and produce training records for later review.
Privacy and Safety Model
These adapters do not provide safety guarantees by themselves.
The recommended deployment model is:
model proposes
application validates
user approves sensitive actions
tool layer executes only after policy checks
Sensitive data should be protected by the host application, not by the model alone.
Recommended controls:
redact personal data before web search,
block private identifiers from external queries,
require explicit user approval for camera, contacts, calendar, files, messages, location, and account access,
validate all executor outputs against a strict schema,
reject malformed or unauthorized tool requests,
prevent the model from self-authorizing actions.
The model should never be the final authority for privacy-sensitive execution.
Web Search Guidance
If used in an assistant with web access, these adapters should operate behind a query firewall.
Before any query leaves the device:
1. detect private or sensitive information,
2. redact or generalize private fields,
3. block secrets, account identifiers, personal documents, and private contacts,
4. execute only the sanitized query,
5. keep raw personal context local.
Acceptable:
"best local LLM runtimes for iOS"
"Qwen3 GGUF LoRA adapter loading"
"Swift llama.cpp LoRA support"
Blocked or redacted:
"search the web for my private email thread"
"upload my contacts and find patterns"
"search using my exact home address"
"send my API key to compare services"
Evaluation
Recommended evaluation areas:
Runtime
adapter load success,
adapter activation success,
cold start time,
memory use,
token throughput,
context initialization reliability,
unload/reload stability.
Slot Accuracy
Cortex routing accuracy,
Executor JSON validity,
Mouth response quality,
Mimicry meaning preservation,
REM trace compression quality.
Safety and Privacy
personal-data leakage tests,
unauthorized tool-call tests,
prompt-injection resistance,
executor schema compliance,
refusal to self-authorize sensitive actions.
Suggested Minimum Gates
For production-like use:
Executor JSON validity: 99%+
Unauthorized tool-call rate: 0%
Personal-data leakage in web queries: 0%
Malformed capability request rejection: 100%
Context-load fallback success: required
Limitations
Known limitations:
These are adapters, not standalone models.
Behavior depends strongly on the shared base model.
Output quality depends on the prompt contract and runtime sampling settings.
Tool use must be controlled externally.
The executor adapter should be validated heavily before any real capability execution.
Adapters may not generalize outside the Lumen runtime design.
Recommended Sampling
Suggested starting points:
Slot	Temperature	Top-p	Max Tokens
Cortex	0.15	0.85	220
Executor	0.0	0.1	180
Mouth	0.55	0.9	420
Mimicry	0.2	0.8	160
REM	0.35	0.9	900
These are starting values only. Tune against your runtime evals.
Training Details
Training details are not included in this card yet.
Recommended additions before broad release:
base model revision,
dataset sources,
synthetic data generation process,
filtering process,
training framework,
LoRA rank/alpha/dropout,
number of steps,
context length,
optimizer,
quantization method,
evaluation results.
Citation
If you use this repository, cite it as:
@misc{lumen-qwen3-bootstrap-adapters-gguf,
  title        = {Lumen Qwen3 Bootstrap Adapters GGUF},
  author       = {ales27pm},
  year         = {2026},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/ales27pm/lumen-qwen3-bootstrap-adapters-gguf}}
}
Disclaimer
This repository provides experimental role adapters for local assistant research and Lumen runtime development.
The adapters should not be treated as a complete safety system. Applications using them must implement their own validation, permission handling, privacy protection, and tool-use controls.