1. One Engine, Many Tools
Accelerated Logic is more than a chat window. Alongside the multi-agent workspace it ships browser-based studios for voiceovers, transcription, presentations, 3D, writing, and project organization. Public guide pages explain what each tool does and where its data goes.
Most AI-assisted creative tools reuse models you have equipped in the Model Organizer. Local Voice Studio is a separate Kokoro speech model, and Transcribe uses Whisper; both run in the browser after their model files download.
| Tool | Route | What it produces | Runs on |
|---|---|---|---|
| Logic Studio | /logicstudio | A Google-Drive-style hub that launches the other tools and organises your decks, transcripts, and notes | Browser |
| Decks (VIBE) | /vibe | Pitch decks, posters, stories, cards & invitations as editable HTML artboards | Equipped models |
| Transcribe | /transcribe | Speech-to-text with timestamps, translation, and SRT/VTT/TXT/JSON export | Whisper on WebGPU/WASM |
| Local Voice Studio | /local-tts | Generate, preview, and download WAV voiceovers; insert generated audio into a video timeline | Kokoro 82M in the browser |
| PolyForge | /polyforge | 3D models with GLTF / OBJ / STL export | Equipped models + WebGL |
| Humanizer | /humanizer | Rewrites machine-sounding prose; 60+ local rules plus optional AI pass | Local rules (+ model) |
2. Logic Studio — The Hub
Logic Studio (/logicstudio) is the launcher and file manager for the creative tools. It presents a familiar cloud-drive style grid with folders, recent items, and category filters (Decks, Transcribe, PolyForge, Humanizer, Notes).
What you can do here:
- Open any tool in an embedded, sandboxed preview frame without leaving the hub — or pop it into a standalone browser tab with the fullscreen/open buttons.
- Create and organise notes with a rich editor (bold, italic, lists), rename/duplicate/delete items, and search everything with the command box.
- Manage models in place: because the embedded tools share the chat engine, you can open the Model Organizer from inside the hub and pick which model drives the tools.
Note: the embedded tool frames run with a restricted sandbox and talk to the parent only through validated messages, so a tool page cannot read the chat shell or your stored keys.
3. AI Decks (VIBE) — From a Feeling to an Artboard
Decks (/vibe) turns a description of a mood, an audience, and a purpose into a real HTML artboard rather than a flat image. Supported formats include pitch decks, posters, landing pages, social stories, greeting cards, and invitations.
Text stays selectable and editable, layout reflows on small screens, and you can change a colour or headline in the source without regenerating. Image models routinely misspell and distort text; emitting markup produces a true document.
Every artboard exposes its own HTML. Tweak spacing, swap a palette, or delete a slide, then present full-screen. The first generation is rarely final — editing the part you like beats starting over.
Model choice matters: VIBE uses whatever you have equipped in the Model Organizer. Stronger instruction-following models produce better-structured, multi-slide layouts; small local models work but tend toward simpler compositions.
4. Transcribe — On-Device Speech to Text
Transcribe (/transcribe) runs an OpenAI Whisper model entirely in your browser using WebGPU when available and falling back to a WebAssembly (WASM) backend otherwise. Audio and video are processed on your device — nothing is uploaded for transcription.
Workflow:
- Drop in an audio/video file (or record). On first run the chosen Whisper model downloads and is cached.
- Transcription produces word/segment timestamps that map the transcript back to the media timeline.
- Optionally translate the transcript using your equipped chat model.
- Export as
.srt,.vtt,.txt, or.json.
If WebGPU is unavailable, the first run may take longer while the WASM backend initialises; Safari and older Firefox use this fallback automatically.
5. Local Voice Studio — Kokoro Text to Speech
Local Voice Studio (/tools/tts.html) creates English WAV speech with Kokoro 82M through Transformers.js. The first use downloads about 100 MB of model files and voice data. Speech generation runs in your browser; the tool does not upload your script to an AI API.
Ways to use it:
- Paste a script into Local Voice Studio, choose an American or British English voice, preview the result, and download a WAV.
- Choose Voiceover from the chat + menu, or request a voiceover in your prompt. Once the assistant finishes, a local audio card appears on its reply with playback and WAV download controls.
- In Decks Studio, generate speech and insert it at the video timeline playhead as an editable audio clip.
The script supports up to 12,000 characters. The browser downloads model files from Hugging Face; generated audio is 24 kHz mono WAV.
6. PolyForge — 3D Modeling in the Browser
PolyForge AI is a WebGL 3D modeling studio launched from Logic Studio. Describe or sculpt a model, preview it in an interactive 3D viewport, and export it in standard interchange formats.
Like the other tools, PolyForge streams AI assistance through your equipped workspace model via the shared in-page bridge, so your key configuration and provider choices carry over automatically.
7. Humanizer — Make Machine Text Read Naturally
Humanizer (/humanizer) targets the habits that make writing look generated: stacked tricolons, hedging preambles, the "it's not just X, it's Y" frame, uniform sentence length, and vocabulary clustering around words like delve, leverage, robust, seamless.
Two layers:
- Local rule pass (free, instant): more than 60 deterministic, transparent transformations run entirely in your browser with no network request — the same input always produces the same output.
- Optional AI rewrite: sends the passage to a model you configured (costs a request against your own key) for a deeper rewrite; you can run the rules after the AI to clean up.
A live readability score and clickable list of flagged phrases shows exactly what changed. No tool can guarantee passing a given AI detector — detectors disagree and false-positive on non-native English — but the rules reliably flatten the mechanical rhythm.
8. Where Tool Files Are Stored
Tool artifacts stay on your device. Decks, transcripts, notes, and 3D projects are saved to the browser's local storage / IndexedDB on your machine; export buttons let you download standard files (SRT, GLTF, HTML) to your own disk. Connect Google Drive from Logic Studio or the workspace if you want a cloud mirror of that work (see Part 17).
9. Which Tool Should I Use? A Decision Matrix
| You want to... | Use | Why this one |
|---|---|---|
| Make slides/posters/cards with AI layout | Decks (VIBE) — /vibe | Real editable HTML output; text you can retype, recolor, reorder |
| Turn a recording into text with timestamps | Transcribe — /transcribe | On-device Whisper; SRT/VTT export for subtitles |
| Voice-over a script without a mic or actor | Local Voice Studio — /local-tts | Kokoro WAV export; on-device; English voices |
| Fix prose that sounds AI-generated | Humanizer — /humanizer | Deterministic local rules + optional AI pass; readability score |
| Design a 3D asset or printable model | PolyForge — via /logicstudio | GLTF/OBJ/STL export; AI-assisted sculpting in WebGL |
| Organize all of the above in one place | Logic Studio — /logicstudio | Hub, folders, notes, recent items, embedded tools |
| AI images for a deck background | Chat image gen (Part 18) or Decks artboard | Generated images rasterize fine as backgrounds; keep words as real HTML text |
10. A Real Pipeline: Recording → Transcript → Publishable Notes
Concrete, start-to-finish, with the tools this app actually ships:
- Transcribe. Open
/transcribe, drop the episode file, let Whisper run (WebGPU if available, else WASM). Export.srtfor subtitles and.txtfor the prose. - Structure. In chat: "Here is the raw transcript: ... Turn it into show notes: 3-sentence summary, 6 key takeaways, 4 timestamped chapters from the SRT." Attach the
.txt. - Humanize. Take the assistant's draft — AI prose tics are common in zero-shot summaries — and run it through
/humanizer; apply the local rules pass, skim the flagged phrases, accept the good fixes, then optionally do one light AI rewrite for rhythm. - Voice it back. Want an audio teaser? Paste the 3-sentence summary into Local Voice Studio, pick a voice, download the WAV, attach it to the episode page.
- Archive. Save notes into Logic Studio notes (or a folder synced with Drive) so the episode workspace lives in one place.
What this pipeline never requires: an API key, a server round-trip for audio processing, or manual timestamp math. The only network legs are the initial model downloads and any chat calls you make to cloud models.
11. A Real Pipeline: The 20-Minute Client Deck with Voiceover
- Brief → outline in chat. "Client Acme wants a 10-slide security-review deck. Audience: CTO + 2 engineers. Give me a slide-by-slide outline with the story arc." Attach any requirements doc.
- Outline → artboards in VIBE. Open
/vibe, describe format (pitch deck), audience, and paste the outline. Stronger equipped models produce cleaner multi-slide grids; small local models work but design simpler layouts. - Edit the 20% that matters. Open the artboard source, fix the headline wording, swap the palette to Acme's colors, delete the fluff slide. Direct editing beats regenerating.
- Present or narrate. Present full-screen from the browser, or generate a per-slide voiceover in Local Voice Studio and insert audio clips at the playhead for an async review video.
12. Humanizer Deep Dive — What the Local Rule Pass Actually Catches
The deterministic pass is a set of named, inspectable transformations — not a black-box rewrite. Categories it targets:
The honest boundary: the pass removes mechanical markers of generated prose. It cannot and does not restyle an author's underlying voice, cannot fact-check, and — as the tool itself warns — no rewrite guarantees passing every AI detector, which disagree and skew against non-native English writers.
13. Tool Data & Privacy — The Consolidated Map
| Tool | On-device? | What leaves the browser |
|---|---|---|
| Logic Studio (notes, org) | Yes — IndexedDB | Embedded tool frames are sandboxed; nothing auto-uploads |
| Transcribe (Whisper) | Yes — WebGPU/WASM | Nothing for transcription; optional translation step sends text to your equipped chat model |
| Local Voice Studio (Kokoro) | Yes — after model download | Only the one-time ~100 MB model fetch from Hugging Face; scripts never go to an AI API |
| Decks / PolyForge (AI-assisted) | Artboards on-device | Generation prompts go to your equipped model (same path as chat; Part 22) |
| Humanizer (rules) | Yes — fully offline | Nothing; optional AI rewrite sends the passage to your configured model |
| Model downloads (all tools) | — | CDN fetches from model hosts (e.g. Hugging Face) on first use; cacheable, clearable |