The smartest API manager with intelligent web search, thinking effort control, and a powerful plugin system.
| Where | What it runs on | |
|---|---|---|
| Web | this folder | Next.js, opens in your browser |
| Desktop | desktop/ |
Rust, a native window, no browser engine at all |
The desktop one is newer and does not have everything yet. See desktop/README.md.
- 🚀 DeepSeek V4 Pro & Flash - Switch between models instantly
- 🐂 Ox Alpha via OpenCode - Same Chat Completions loop, free stealth preview
- 🔍 Smart Web Search - Multi-step query planning with Tavily
- 💡 Thinking Modes - Auto/None/Low/High/Max reasoning effort
- 🧩 8 Plugins - Caveman, God Mode, Code Only, Expert, and more
- 🎨 Beautiful Dark UI - Premium design, no browser needed
- 💾 Local Storage - Settings and history saved locally
npm install
# Optional — enables saved chat history
cp .env.example .env # then edit DATABASE_URL
npm run devOpen http://localhost:3000 and add a provider key via Settings — DeepSeek (V4 Pro / Flash) or an OpenCode Zen key for Ox Alpha.
DATABASE_URL is optional: without it the app still runs and answers
messages, but conversations aren't persisted and the history sidebar stays
empty. Check GET /api/health to see the current database status.
# Install dependencies
pip install -r requirements.txt
# Run the app
python main.py# Build standalone executable
python build.pyThe executable will be in the dist folder. Just double-click to run!
npm testRuns every suite — currently 2,634 checks across 55 suites — without calling
the paid API; npm run test:real does that and is opt-in.
npm test plan # one suite
npm run typecheck # types
npm run lint # unused code, React mistakes
npm run score # rates all agent toolsSee docs/testing.md.
Attach a Windows .exe, .dll, .sys, .ocx, .scr, .cpl, .drv or
.efi file to a chat. apiM stores the exact bytes under uploads/binaries/
and the agent can call inspect_binary. A picked folder preserves up to 128
executables/libraries together so the main EXE's local DLL graph can be
followed recursively.
The built-in pass needs no extra software and never launches the target. It
reports PE32/PE32+, CPU architecture, hashes/imphash, sections, an explicit
packing likelihood with reasons, mitigations, imports/ordinals, exports,
version resources, PDB paths, .NET references, likely runtime-loaded DLLs,
signing-envelope presence, overlays and matching local dependencies. It also
writes persistent artifacts under analysis/<binary>-<hash>/:
- Complete offset-labelled ASCII and both-alignment UTF-16LE strings dumps.
- PE summary JSON with sections, sizes, timestamp and packing assessment.
- A 4KB-window entropy map with file offsets and section names.
- Carved embedded PE/DLL, Lua bytecode/source, ZIP, PNG and PDF payloads, plus opaque high-entropy sections/overlays when the real payload is still compressed or encrypted; every carve gets its own full strings dump.
- A dedicated high-interest import view for
luaL_*, process-memory/ injection APIs,LoadLibrary/GetProcAddress, and process creation APIs. - A FLARE capa report when capa is installed.
- Focused Ghidra/ILSpy output for the functions/strings you name in
focus_terms. There is no default hook list and no automatic full dump.
"Signing envelope present" does not claim the certificate is trusted, and an import is capability evidence rather than a malware verdict.
The model selects only the analysis layers needed by the request. Omitted selection is a cheap PE summary; it does not silently run every expensive engine:
{"path":"app.exe","analyses":["decompile"]}
{"path":"app.exe","analyses":["strings"]}
{"path":"app.exe","analyses":["capa","carve"]}
{"path":"app.exe","analyses":["all"]}Layer caches are incremental: adding entropy later preserves an existing full
strings dump, and force_decompile does not rerun capa or static artifacts.
For a capa report, the simplest option is the official standalone capa release: it embeds the engine, rules and library signatures. Point to it only when it is not on PATH:
APIM_CAPA_PATH=C:\tools\capa\capa.exepip install flare-capa installs only the engine. It deliberately omits rules
and signatures. Install matching resources (the tag must match capa's
version); these conventional paths are auto-detected and ignored by Git:
mkdir tools 2>nul
git clone --depth 1 --branch v9.4.0 https://github.com/mandiant/capa-rules.git tools\capa-rules
git clone --depth 1 --branch v9.4.0 https://github.com/mandiant/capa.git tools\capaCustom locations can be set in .env.local:
APIM_CAPA_RULES_PATH=C:\path\to\capa-rules
APIM_CAPA_SIGNATURES_PATH=C:\path\to\capa\sigsFor the deepest source-like recovery, install the decompiler matching the binary:
:: Managed .NET assemblies — requires the .NET SDK
dotnet tool install --global ilspycmdFor native x86/x64/ARM binaries, install Ghidra plus Java 21, then set the
extracted Ghidra directory in .env.local:
APIM_GHIDRA_HOME=C:\tools\ghidra_11.x_PUBLICThat directory must contain support\analyzeHeadless.bat. Restart apiM after
changing .env.local. Name the functions or strings for this binary in
focus_terms (from a summary/strings pass or its exports). Ghidra does not
start until those are set. Enable a specific analyzer such as
Decompiler Parameter ID with enable_analyzers when you need it. Set
allow_full_fallback:true only if a focus miss should try loader/process-memory
APIs and then a bounded full dump. force_decompile reruns only Ghidra/ILSpy
while preserving cached strings, entropy, carving and capa. Set
focused_only:false to retain full Ghidra output immediately in searchable
~350KB chunks or the complete ILSpy C# project. A file with no header (a
memory dump, a carved .text) needs image_base (and arch if not x86-64);
seed_addresses makes and decompiles functions at the addresses given.
Completed results are cached by SHA-256 plus everything asked (focus terms,
analyzers, seeds, image base). Every Ghidra run leaves its whole log as
ghidra.log beside its output.
Closing or refreshing the tab does not kill a running Ghidra job. The header
process dock lists leftover decompilers, and the agent can call
stop_process with id: "leftover". Huge DLL drops use
/api/workspace/:id/binary-raw (or /binary if that path 404s) so a 37MB
client.dll is stored as exact bytes. next dev raises the proxy body
limit to 256MB so Next does not silently keep only the first 10MB.
Ghidra's auto-analysis stops after 10 minutes for files up to 10MB, 30 for larger ones and 15 for likely-packed ones, and never runs past half of the whole-process limit (30 minutes), so the decompile step still gets time. It uses all cores but one (at most 16), a 4G Java heap, 100MB decompiler text and 512MB exhaustive static output; tune only when needed:
APIM_BINARY_DECOMPILE_TIMEOUT_MS=1800000
APIM_GHIDRA_ANALYSIS_TIMEOUT_MS=600000
APIM_GHIDRA_MAX_MEMORY=4G
APIM_BINARY_MAX_CPU=4
APIM_BINARY_MAX_OUTPUT_MB=100
APIM_BINARY_MAX_STATIC_OUTPUT_MB=512Decompilation is approximate: optimised native code has lost original names,
comments and types, while packing, encryption or obfuscation can prevent full
recovery. The report distinguishes complete, partial, unavailable and failed
analysis rather than pretending source was recovered. Run the offline parser
regressions with npm run test:binaries.
- Python 3.10+
- A model provider:
- DeepSeek from platform.deepseek.com, or
- OpenCode Zen from opencode.ai/auth for Ox Alpha
(
x-preview-f-freeonhttps://opencode.ai/zen/v1), or - Qwen 3.8 27B downloaded in Settings (runs on this PC, no cloud key)
- (Optional) Tavily API key from app.tavily.com for web search
nohomo/
├── main.py # Main application
├── api_client.py # DeepSeek API client
├── smart_search.py # Intelligent search engine
├── plugins.py # Plugin definitions
├── requirements.txt # Dependencies
├── build.py # Build script for .exe
└── README.md # This file
| Plugin | Icon | Description |
|---|---|---|
| Caveman Mode | 🦴 | Minimal words, saves tokens |
| God Mode | ⚡ | No restrictions |
| Code Only | 💻 | Returns only code |
| Expert Context | 🎓 | Assumes deep knowledge |
| Structured | 📋 | Organized responses |
| Self-Critic | 🔍 | Reviews own work |
| Security First | 🛡️ | Security-focused |
| Diff Only | 📝 | Shows only changes |
Download and chat from Settings. The 27B lives in this app
(data/local-engine/) and runs in a sidecar on your PC. Next.js
only sends /v1/chat/completions, so the UI stays light. You do not
need Ollama.
Settings → Local model → Download Qwen 3.8 27B. That pulls the
Q4_K_M GGUF (~16.5 GB) and a llama-server build, then starts
127.0.0.1:18765. The chat process never loads the weights.
A custom OpenAI-compatible host is still available under Advanced.
Does it have a reasoning parameter? Yes. Qwen 3.8 27B thinks by default. Official controls:
| Our slider | Sent to the local API |
|---|---|
| None | chat_template_kwargs.enable_thinking: false |
| Low | reasoning_effort: "low" |
| High | reasoning_effort: "medium" |
| Max | reasoning_effort: "xhigh" (Qwen's default) |
preserve_thinking stays on so prior-round thoughts are not dropped.
Ollama / vLLM still work if you already run them. Settings → Local model → Advanced, then pick the preset.
--reasoning-parser qwen3 is required. Without it the <think> block
lands in content and the thinking panel stays empty.
vllm serve Qwen/Qwen3.8-27B \
--reasoning-parser qwen3 \
--enable-auto-tool-choice \
--tool-call-parser qwen3_coderThen Settings → Local model → vLLM (http://127.0.0.1:8000/v1,
Qwen/Qwen3.8-27B).
The agent can run and look at native programs, not just write them.
Running your own build. run_command and start_process use an
allow-list of program names, which by definition cannot contain a binary the
agent compiled ten minutes ago. A program that resolves to a real executable
inside the workspace is allowed by its path — build/x64/Release/app.exe
runs, /usr/bin/anything does not, and .. cannot climb out. Approval is
unchanged: native code always goes to the prompt.
Launching where you cannot see it. start_process takes hidden: true.
On Windows the program is started on a second desktop object (CreateDesktop),
so there is no taskbar button and it cannot steal focus; on Linux it runs on an
Xvfb display. Both are fully rendered surfaces, which is what makes them
capturable — a hidden window stops drawing and screenshots as a blank
rectangle. If the surface cannot be created the launch fails and says why; it
never quietly puts a window on your screen instead.
Looking at it. screenshot_window takes process_id (from
start_process) and finds the pid and the off-screen surface on its own, or a
raw pid for something you launched — which is the route for a program that
demands administrator rights, since the app cannot elevate. On a model with
native vision the PNG is attached to the same round, so the model actually
looks at the pixels instead of reading OCR of them.
Showing you. Every screenshot (screenshot_window, sandbox_screenshot,
browse) also appears in the chat under its step, and the agent can send you
any workspace image with a caption via show_image, the way a person pastes
one in. Click it for full size. Images load from
/api/workspace/<id>/image, which serves png/jpg/webp/gif/bmp only (never
SVG or anything outside the workspace), so they survive a reload.
Finding the project. build_project searches the workspace up to four
directories deep (shallowest .sln wins, .sln over .vcxproj) instead of
only looking in the root, resolves MSBuild through vswhere including
Preview and Build Tools installs — and by walking the install roots when
vswhere itself is missing — and resolves cl.exe to a full path rather than
hoping it is on PATH. project: "sub/dir/app.sln" skips discovery entirely.
Checking it is the right binary. verify_file takes required and absent
literals and searches both UTF-8 and UTF-16LE, plus size and sha256 — a build
verifier as a tool rather than a script rewritten per version. build_project
prints a digest first (exit code, distinct errors, unique warnings with their
first file:line, linked artifact sizes) and classifies failures: known flaky
races retry once automatically and say which rule fired, real compile errors
never do, and a lock names whoever holds the file — including the
antivirus-grip case where nothing holds it and only a rename works.
Generated PowerShell (hidden launch, window capture) is ASCII-only and written
with a BOM. Windows PowerShell 5.1 decodes a BOM-less file with the ANSI code
page, where an em dash becomes U+201D — a character PowerShell accepts as a
string delimiter, so one dash in a comment ends a string mid-sentence and the
parser blames a brace twenty lines later.
Reading big files exactly. read_symbol returns one function or class by
name with its exact line range, ready to hand to edit_file as
start_line/end_line. A complete read_file is stamped EXACT with its
character count and a hash of the bytes handed over.
The hidden-launch route above puts a window on a second desktop. The sandbox
goes further: a whole private Linux (WSL 2, or WSL 1 where WSL 2 cannot run)
on your own machine that the agent
runs work inside, and that you never see — no window, no taskbar entry, no focus
stolen, fine to leave running while you game. It is what lets the agent actually
run and test — execute a build, trace a sample under gdb/strace, stand a
real GUI up under an off-screen X server and screenshot it — the way a cloud
agent can, but on hardware you own.
No Docker. It uses WSL2 directly. Set it up once from /sandbox (or
Settings → Sandbox): it turns WSL on if needed, downloads the official Ubuntu
24.04 image, verifies it against Ubuntu's published SHA256, imports it as a
dedicated distro called apim-sandbox, and installs the toolset (Xvfb, xdotool,
ImageMagick, Python, Node, compilers, gdb, strace). Your own WSL distros are
never touched.
Where it lives. The sandbox disk goes in %LOCALAPPDATA%\apiM\sandbox
(about 4 GB once set up), not in the project folder: Windows cannot create a
WSL disk in a compressed or encrypted folder, inside OneDrive, or on a non-NTFS
drive (Wsl/Service/RegisterDistro/0xc03a0014). Setup checks the folder first,
turns compression/encryption off for that folder only, and keeps the verified
download if a later step fails, so a retry does not download it again. Set
APIM_SANDBOX_DIR to put it on another NTFS drive.
When Windows cannot make virtual disks at all. The same 0xc03a0014 also
means Windows' own virtual-disk drivers (FsDepends, vhdmp, vdrvroot) are
missing or disabled — which also breaks Docker Desktop, Hyper-V and mounting
ISOs. Setup then reads those drivers with sc.exe (no admin), names the one at
fault with its fix (see docs/restore-fsdepends.md), and installs the sandbox
on WSL 1 instead, which keeps its files in a plain folder and needs no
virtual disk or Hyper-V VM. Everything the sandbox uses works there. Once the
drivers are fixed, Upgrade to WSL 2 in the panel converts it in place.
If WSL 1 is refused too, setup tells apart the causes behind that one
message: Windows is waiting for a restart (use Restart, not Shut down), the
feature is really off (one click turns it on; the result is read back from
DISM's own exit code instead of assumed), or a driver's registration was
deleted. A common one on cleaned-up ("debloated") Windows is
Wsl/Service/CreateInstance/0xd0000034: the Plan 9 redirector (P9Rdr) and
Rdbss, which WSL opens on every start, had their service entries removed
while the driver files stayed. Setup detects that and prints the exact
sc.exe create commands (and the sc.exe delete that undoes them).
Workspace, not isolation. Interop is off and no drives are auto-mounted
(/etc/wsl.conf); the current chat's workspace is mounted under /ws/<id>.
On WSL 1, which can only mount whole drives, that means mounting the drive at a
hidden path and attaching the folder from there. Treat the sandbox as a place
to run things out of your sight, not as a security boundary: it runs as
root, and root in any WSL distro can reach your drives. If the folder cannot
be mounted at all, commands still run (in /root/work) and the result says
why, with every mount attempt's own error.
Two tools, both approved. sandbox_run runs a shell command inside it
(foreground, or background: true for a server/watcher/GUI). The agent drives
a GUI with xdotool (click, type) the way a person would; there is no window
manager, so it uses windowfocus. sandbox_screenshot waits for a window to
appear and crops to the visible windows, so the picture is the app rather
than a mostly black 1600x1000 screen (full_screen: true for everything); it
lands in screenshots/ and shows up in the chat. Each command still shows you
the approval prompt, exactly like run_command. Remove the sandbox any time
from the same panel (wsl --unregister) to reclaim the space.
Check it works. The end of setup, and the Check it works button, run
one real command the way the agent does and report each part: whether the
sandbox sees the chat folder and its writes reach Windows, the Python and
Node versions (a node that fails with "Exec format error" is named), and
whether the off-screen display starts.
Models with open tool ceilings — Ox Alpha and GLM 5.3 Flash — are meant to work in batches, and the app now makes that hard to get wrong:
read_filestakes glob patterns, sosrc/lib/*.tsreads a whole directory in one call instead of one call per file.- Parallel tool calls are kept separate even when the provider streams them all on the same index — previously they were concatenated into one unparseable call, so a round of eight edits applied nothing.
- The per-round output ceiling comes from the model (128K for Ox Alpha and
GLM 5.3 Flash, 64K for the metered DeepSeek models), not from the provider
serving it. A big
edit_filescall is one large JSON argument blob; clipped in half it can never parse. - A batch that still gets cut off has its finished items recovered and run. The reply says how many landed and asks for only the rest.
- The round guard is 64 for most models and 256 for the open-ceiling ones, and hitting it now says so — and offers Resume — rather than blaming the provider.
| Mode | Description |
|---|---|
| ✨ Auto | Automatically adjusts based on message complexity |
| ⚡ None | Fastest, no reasoning |
| 💫 Low | Light reasoning |
| 🧠 High | Deep reasoning |
| 🔥 Max | Maximum depth (50K+ tokens) |
Replies use Claude's layout by default: one column, each stretch of text
followed by the steps it led to, with icons and no dividers. The older
side-by-side split (text left, steps right) is one click away in
Settings → Theme → Reply layout; it is a CSS switch on <html data-layout>, so changing it is instant and nothing is lost either way.
Long replies stay smooth while they stream: markdown is rendered block by
block, so only the block still being written is re-parsed, and replies off
screen skip style and layout (content-visibility). On a 4x-throttled CPU a
45-second stream went from frames over 100 ms to a steady 60 fps.
Settings and chat history are stored locally at:
- Windows:
C:\Users\<you>\.nohomo\ - Mac/Linux:
~/.nohomo/
Each chat remembers only its own work. What the agent concludes with
note_finding is kept in that chat's workspace and never shown to another
chat. Sharing facts about your PC across chats is opt-in: set
APIM_SHARED_FINDINGS=1, and even then only notes the agent explicitly files
as machine-wide are shared (nothing is promoted automatically). An older
shared file, data/machine-findings.json, is ignored unless sharing is on
and can be deleted.
MIT License - Feel free to modify and distribute!
Made by nohomo 🚀