GAEOS CREATOR

A local-first, fully autonomous agentic development environment. By Mythos Systems.

GAEOS CREATOR is a desktop workbench for building software with AI models that run on your own hardware. It hosts a real agent - Themis - that reads a codebase, writes and runs code, drives git, browses the web, produces documents, orchestrates swarms of sub-agents, and can operate unattended for hours; and it gives you the instruments to steer, inspect, and constrain that work. Nothing leaves the machine unless you send it there.

It is built for one operator on one workstation doing serious work: reverse-engineering repositories, standing up projects, and building autonomous systems - with models, memory, tools, and project context held in common across every engine it can route to, local or cloud.

---

Contents

• Architecture
• The Themis agent
• Multi-agent orchestration
• Memory and code intelligence
• Models and inference
• Model discovery and acquisition
• Providers and routing
• Personas
• Tools
• Skills and expertise
• The console
• Two browsers
• Documents and archives
• Voice
• MCP
• The gateway
• Self-healing
• Self-refinement
• Missions, checkpoints, snapshots
• Safety, identity, and the vault
• Observability
• Getting started

---

Architecture

A Tauri 2 + Svelte 5 desktop shell over a Rust core and a vendored Python agent engine.

Layer	Stack	Role
Shell	Svelte 5 (runes) + TypeScript, Tauri 2	Console, model matrix, persona studio, settings, telemetry - 40+ components
Core	Rust (Tokio)	LM Studio control, the vault, profiles, runtime diagnosis, the agent browser, AST indexing, voice, gateway, dependency management - 35+ modules, 130+ Tauri commands
Engine	Python ("Themis")	ReAct loop, orchestration, tools, skills, memory, providers, refinement - 573 tests

Models load through LM Studio onto a llama.cpp runtime; the app drives both directly. Cloud providers are reachable through a credentialed vault when you want them, but the default and the design centre is local.

---

The Themis agent

Themis is a real ReAct agent loop - reason → act → observe, repeated until the objective is met. It is not a chat wrapper.

• Completion discipline - a task is done when the objective is satisfied and verified, not when the model stops talking. The loop keeps working, or reports plainly why it stopped.
• Objective preservation - long runs are compacted without ever losing the original objective, so a week-long session never forgets what it set out to do.
• Permission modes - read-only, supervised (writes ask), or bypass (unattended). The mode governs how far the agent's reach extends across the filesystem and the machine.
• Effort scaling - the engine sizes its own reasoning effort to the task.
• Dialect-tolerant tool calls - handles both native tool-calling and the <function=…> text dialect some local models emit, so a small model's tool calls execute instead of printing.
• Structured planning - a plan engine and planner decompose work before execution, with a validator gating results.

---

Multi-agent orchestration

Themis is not just one agent. It can convene a team.

• Orchestrator - decomposes a goal into SubTasks, assigns each a SubAgentRole, runs them, and collects SubTaskResults.
• Swarm manager - coordinates many concurrent sub-agents.
• Wave controller - drives work in waves, detecting and breaking stalls (WaveStalled) rather than hanging.
• Handoff, synthesizer, reducer, graph reducer - sub-agent results are handed off, synthesised, and reduced into a coherent whole.
• Agent topology + DAG canvas - the live agent graph is exposed as data and drawn visually, so you can see the shape of the team working on your problem.

---

Memory and code intelligence

Memory that survives across sessions, and a structural understanding of code.

• Three memory registers - episodic (what happened), semantic (what is known), and procedural (how things are done), scoped per project. A session started next week recalls what last week decided.
• Graph memory - a graph database with graph_query / graph_find_nodes for relationship-aware recall.
• Vector search + semantic search - retrieval over embedded content.
• AST indexing - an AST chunker and graph builder index the codebase into a code graph; the RAG indexer panel drives and shows it.
• Context manager + compactor - active management of the working context so hour-long runs stay coherent within the model's real ceiling.

---

Models and inference

Full control of local inference, driven from the app.

• LM Studio control - list the library, load, unload-all, release VRAM, read status and the master context, all without leaving GAEOS CREATOR.
• Context length override - set default and per-model context length, with the ceiling learned from what actually fits your VRAM rather than re-failing the same load. When VRAM is barely short, the loader retries with system-RAM offload before reducing the context window, so many models load at full context on cards that would otherwise need a fallback.
• Runtime engines - inspect installed llama.cpp runtime builds, diagnose a load failure (unhealthy runtime, rejected template, timeout, out-of-memory…), and apply the fix.
• Benchmarking - benchmark a model in place.
• Inference telemetry - live token/throughput and runtime behaviour.
• The status bar - active model, context length and max, and acquisitions, always in view with an inline model-tools menu.

---

Model discovery and acquisition

Find and pull models without a browser.

• Hugging Face hub search and download - search the hub, download GGUFs, scan active and partial downloads, resume, and cancel - all in-app.
• Download tray - live progress for concurrent acquisitions.
• Model matrix + grid + cards - browse by category with per-model detail.
• Recommender - suggests models that fit your hardware.
• Utility model - a small Qwen coder model is a required first download, used for the app's own core logic and automation.

---

Providers and routing

One agent, many engines, unified.

• Local + cloud providers - LM Studio local, plus Anthropic, OpenAI-compatible, and Devin, behind one interface.
• Model router - selects the right model for a task from a configurable policy; the router config is inspectable and editable.
• Integration matrix - curated vendors (Claude, ChatGPT, Kimi, Devin, zcode…) plus ~170 more discovered from the models.dev catalog OpenCode ships: one searchable list with OAuth-first auth (ChatGPT and Claude logins before API keys), in-app connection tests, enable/disable gating, and honest errors where a vendor has no routable endpoint.

---

Personas

• Eight personas with a persona studio to compose them, a persona optimizer, role sets, and per-persona context - shaping voice and stance without touching the agent's authority.

---

The tool belt

The engine gives the agent a broad, confined tool set (every write and command bound by the permission mode):

Code & files - read_file, write_file, edit_file, apply_patch, revert_patch, list_files, search_files, grep_codebase, compare_files, compute_hash. Execution - run_command, runtime_status. Version control - git_operation, with a visual diff viewer. Retrieval - semantic_search, recall_memory, graph_query, graph_find_nodes. Web - web_search, web_fetch, web_scrape (a crawl4ai-style pipeline: inspect a page's structure, extract structured JSON through CSS schemas the model writes from what it sees, run pattern catalogs, or bounded deep crawls). Documents & archives - write_document, list_archive, read_archive_member. Workspace safety - snapshot_workspace, restore_workspace. Self-extension - author_skill, author_mcp_tool - the agent writes new skills and MCP tools to close gaps it finds.

---

Skills and expertise

• ~40 composable skills - deterministic plans spanning building (build_web_frontend, build_go_service, build_python_project, ship_wasm_module, build_gpu_web_graphics), analysis (reverse_engineer, reverse_engineer_protocol, distill_repository, survey_repository_corpus), hardening (rust_audit_unsafe, harden_agent_loop, harden_system), porting/refactoring (port_to_rust, modernize_web_stack, refactor_module), ops (manage_remote_server, administer_web_server, operate_interserver_hosting), security (security_audit, penetration_test_engagement), and documentation (document_project).
• 163 expertise profiles across 48 focus packs - an expertise profile shapes how the agent reasons for a phase; it grants judgement, not authority.
• Self-authored skills - the agent can write and register new ones.

Coverage spans Rust, Go, Python, TypeScript/SvelteKit and the web stack, systems and protocol work, GPU/WASM, repository archaeology, security engineering, and remote operations.

---

The console

The front door. Compose a task, route it to any engine, watch it work.

• Rendered output - Markdown, tables, syntax-highlighted code, live Mermaid diagrams, and draw.io diagrams rendered inline through the official embed, exportable as .drawio, SVG, or PNG.
• Process transparency - the current phase (reasoning, running a tool, waiting on the model), the turn, and elapsed time, expandable into the phases already passed. A quiet local model is visibly working, not hung.
• Stop and halt - the send button becomes a stop while streaming; holding Escape for three seconds halts the run, and the halt is written into the transcript.
• Slash commands - /document, /document:full, /design:frontend, /review, /test, /explain, /plan, /scrape (give a URL and what you want from it; the agent inspects the page, writes an extraction schema, and verifies the result), /draw (a draw.io diagram from a description), /diagram (a Mermaid diagram from a description), /audit:security, and more, plus path shortcuts (/docs, /root, /src) that resolve against the bound project. A command palette exposes the rest.
• Paste - images (screenshots) and documents, from the clipboard or a file manager, on Linux and Windows.
• Living console copy - the idle console speaks in rotating, hour-aware, model-aware lines rather than dead placeholder text.

---

Two browsers

Two surfaces with distinct jobs, on the Claude Code model:

• Preview pane - for local dev servers and pages you want to watch.
• Agent browser - a real Chromium driven over CDP that reads any site, runs JavaScript, and captures network - including sites that refuse to be framed. The agent routes to whichever surface the task needs.

---

Documents and archives

• Document generation - the agent writes structured Markdown natively and converts to .docx / .odt / .pdf via pandoc, auto-selecting an installed PDF engine (pdflatex, xelatex, tectonic, weasyprint, typst…). The Markdown is always written, so content survives even if conversion can't run.
• Archive reading - list and read members inside .zip, .tar (gz/bz2/xz variants), and .rar without unpacking, with zip-slip refused and binary members reported honestly.

---

Voice

• Speech in - transcription via a bundled or detected Whisper.
• Speech out - TTS via Piper or Kokoro.
• Record, cancel, transcribe, and speak, managed from the voice panel.

---

MCP

• MCP client - list, start, and stop MCP servers; enumerate their tools; and call a tool directly.
• MCP authoring - the agent can author_mcp_tool to add capability at runtime.

---

The gateway

A control plane for agent sessions.

• Sessions - start a gateway, create and list sessions, submit prompts, interrupt, and stop.
• Approval flow - the gateway surfaces approval requests and takes your response, so unattended work still asks before crossing a line.

---

Self-healing

• On a load or runtime failure, the engine classifies the error, proposes a deterministic remedy where one exists, and otherwise runs an analysis prompt on whichever model is available - resident model → last-loaded → the utility-model floor - so it can reason about a failure even when nothing is loaded.

---

Self-refinement

Autonomy that never edits the tree it's changing from under you.

• Error review, not auto-repair - failures are captured with a proposed fix. You approve, dismiss, or copy the proposal out to weigh with a stronger model first.
• Missing dependencies become proposals - a detected gap lands here with either an integrated one-click install, or a plan to make it a formal dependency with an install path.
• Worktree-isolated campaigns - an approved fix becomes a durable, scoped task. When armed, a campaign applies each change in a git worktree, verifies it with build-and-test, and merges only on green - a broken change never touches your working tree. Running a campaign is always a separate, deliberate act.

---

Missions, checkpoints, and snapshots

• Missions - long-lived objectives, created and listed.
• Checkpoints - capture and list points in a session you can reason about.
• Workspace snapshots - the agent snapshots and restores the workspace around risky changes.
• Session audit explorer - a full, inspectable event trail of what the agent did.

---

Safety, identity, and the vault

Autonomy here is opt-in and reversible.

• Profiles - per-user containers scoping all data, with password / PIN / MFA scaffold / autolock and a lockout timer.
• The vault - provider credentials encrypted and profile-scoped; never in argv, logs, or prompts.
• Security log + redaction - a security audit log and a text-redaction pass for sensitive output.
• Own-infrastructure only - SSH, web-server, and security capabilities (audit, pentest, hardening) are for the operator's own estate, and every security engagement establishes scope and authorisation as its first step.
• Bounded self-extension - the agent freely extends what it can do (skills, MCP tools); it changes what the application is only by agreement.

---

Observability

• System stats, disk usage, health report - live machine and app health.
• Inference & advanced telemetry - throughput and runtime internals.
• Usage - record and report usage over time.
• Diagnostics log - an inspectable, clearable diagnostics stream.
• Keep system active - hold the machine awake through long unattended runs.

---

Getting started

Prerequisites: LM Studio and a llama.cpp runtime (the app installs and detects both), plus a small set of dependencies the first-run wizard installs with one click. Recommended extras: pandoc, a PDF engine, unrar, OpenSSH, Whisper/Piper for voice, and a Chromium browser for the agent surface.

pnpm install
pnpm run tauri dev      # desktop app
pnpm dev            # web preview only

The engine's Python environment lives in engine/.venv (see engine/VENDOR.md).

Tests

pnpm check                                            # Svelte + TypeScript
cd src-tauri && cargo test                            # Rust core (156)
cd engine && .venv/bin/python -m pytest backend/tests # engine

Repository layout

src/            Svelte 5 front end - console, matrix, persona studio, panels, stores
src-tauri/      Rust core - LM Studio, vault, profiles, browser, AST, voice, gateway
engine/         Vendored Python agent (Themis): loop, orchestration, tools, skills, memory

---

Local-first. Evidence over assertion. Nothing consequential happens without your say-so.