Skip to content
프로젝트

Mikedev115/Aetox-Harness has 125 GitHub stars and 24 forks. GitHot measured 0 stars in 24 hours and +10 in 7 days. Last checked 2026-11-17 02:19 UTC. Last push 2026-11-15.

이 수치를 측정하는 방법

측정된 스타 증가

in 24h
0
in 7 days
+10
in 15 days
업데이트 지연
in 1 month
업데이트 지연

서로 겹치는 기간의 순증가량이며 일별 합계가 아닙니다. 측정값이 없으면 비워 둡니다. 스타는 관심도를 나타내며 품질을 보장하지 않습니다.

소개

Aetox harness는 로컬 우선 방식의 Windows AI 환경으로, 모델, 기술, 팀, 메모리를 하나의 시스템으로 통합합니다. 두 가지 진입점이 있습니다. Assistant는 작업 방식에 맞춰 적응하고 실제 브라우저를 조작합니다. Developer는 코드를 작성하기 전에 약점을 하나씩 짚고, 프로젝트의 보안을 점검하며, 완료를 알리기 전에 프로젝트 테스트를 실행하고, 프로젝트에서 내린 결정을 기억합니다.

생산성

README.md

Original

Aetox

Aetox harness

The environment where an AI works as one system

Aetox Harness is the working environment for AI on your computer — one system where the model, the skills, the team, the code and the memory work together. The more you use it, the more it understands how you work. The job comes back as a file you can open and use, on your machine, on the model you already have.

Assistant

Fits your work — you don't fit yourself to it

"2 hours of meeting audio — summarise it, with who took which action"

You get back: a summary with the topics, the decisions, and the minute each was said at, plus the action items and who owns them — a file in your folder, not text in a chat box.

It knows you in parts — your profile, this machine, each desk, each worker, and the routes you repeat — so it reaches deeper context than a general assistant, without carrying all of it in every request.

recording meetings · receipts · tidying files · disk space · slides · live research · browser · automation · clips and content · teams · open tasks and reminders

The summary of a recorded meeting: topics and decisions with the minute each was said at, and two action items with an owner

Developer

Code that runs — and it remembers what this project decided

It opens the real project: real files, an editor, a terminal, a language server and git. It reads the AETOX.md, AGENTS.md or CLAUDE.md the project already has, runs the project's own tests before it says done, and writes down plainly what it could not verify.

Memory is per project — open a folder and you get that folder's memory: your coding patterns, the decisions already agreed, the team's conventions. Nothing needs explaining twice, and what a chat is about is pulled in when it is needed.

The system makes the model write better code — that is the only thing we sell for code, not the model's own brilliance. The model is yours; whichever one you have.

Don't take our word for it — run it yourself. Every task, starting file and hidden test is published. Run any of them · All the numbers, speed and tokens included →

real files · terminal · git · diagnostics · symbol · MCP tools · the project's own tests · sub-agents

A terminal running npm test to a pass, beside the files changed and lines added and removed

Every number is same-model, and the tasks, starting files and hidden tests are published so you can run them yourself. How it was measured, and every number

Get it from Microsoft Store

Download the Windows installer (.exe) · Aetox CLI · Scoop and portable zip
Windows 10+ · x64 · Free to use · Bring your own model, or run one locally for free

Website · What's new · Reports · ภาษาไทย · 中文

A website task becomes a plan, tool steps and a finished page in Aetox

Scripted walkthrough of the real app, not a benchmark run.

Quick start

  1. Install from the Microsoft Store or with the installer above. Pick one channel and stay with it: the Store build and the installer build keep separate settings, chats and keys.
  2. Connect a model. Open Settings › Models and sign in with ChatGPT, GitHub Copilot or OpenRouter, or paste a key, or point it at LM Studio or Ollama on your machine.
  3. Give it a job. Pick Assistant for files, documents and the web, or Code for a project folder.

One instruction. It works out the steps

The point is not "it can do many things". It is that you hand over one job and it works out what has to happen first, with a real tool at every step, checking each step's result before moving on — and you see every step and can stop at any of them.

Step What it does on its own
1. Reads first Opens the project, reads the README, the database schema, how the project runs, and the documents that matter
2. Plans Splits the job into items, says which one waits on which, and what it does not know yet
3. Works step by step Edits files, writes migrations, runs commands, calls the MCP servers you connected, drives a real browser
4. Checks its own work Runs the tests, reads errors from the language server, opens the page it just built and clicks through it
5. Reports honestly What is done, what does not pass, and what it could not check

Jobs that really take several steps

  • "Build a booking system for my shop" — reads the ask as a spec → designs the database → writes the migration → builds the screens → runs the tests → opens a browser and books a slot itself → reports what is still missing
  • "Research five competitors and make me a comparison table" — drives the browser across tabs, reads page by page → collates → writes an .xlsx
  • "2 hours of meeting audio, summarise it" — transcribes → splits topics and decisions with the minute each was said → pulls the actions and their owners → writes the file
  • "Fix this bug" — reads the stack trace → finds the files involved → fixes → runs the project's tests → loops back if it does not pass

A job too big for one worker — handed to a team, back as the finished set, with who did what.

Why the same model does better

The model thinks. The environment does the rest — with real parts, not simulations.

  • Hands. A real browser with its own tabs and profile, a real terminal, real writers for .docx, .xlsx and .pptx, and a real cut room. It does not describe the spreadsheet to you — it writes the file and opens it to look.
  • Eyes. OCR and document readers that read a scanned page instead of asking a vision model to guess, and a page captured as it was instead of remembered.
  • What the model cannot know. Skills keep it: the 1280×720 frame of a slide room, how an attacker breaks a path check, how a Thai tax invoice rounds — and how you work.
  • A check before it hands back. It runs the tests, opens the file it made, and says plainly what it could not prove.

It learns how you work

An environment that starts from zero every morning is a tool you rent again each day. Aetox keeps what it finds out about you.

  • A way of working counts only when it repeats. One day is an episode; three different days is how you work. It does not decide from a single conversation that this is who you are.
  • You say yes. Anything proposed from outside a turn waits for you, and every line it keeps can be undone from under the answer that added it.
  • Split by who has to read it — but the work can reach all of it. The architecture decides who reads what: your profile rides with every job, what it knows about this machine with the desks that need it, each room's ways with that room, each worker's with that worker. At work it can search the whole history, open any day's note, and pull in the documents on your machine — so nothing has to ride in every request, and nothing is forgotten.
  • It is a folder of plain .md files, not a black box. Your profile, what it knows about this machine, each room's notes, one note per day of work, and the routes it has seen you repeat — written where you can open, edit, copy into another agent, or delete them. Nothing it learns is trapped in a format only Aetox reads.

Where it runs is your choice, and so is the model: 31 providers, cloud and local, asked for their model lists at run time so a new model appears without a new Aetox. Today the whole of it runs on your machine. Every provider

Measured results

Code — five public test suites × 2 public OpenAI models (gpt-6-luna, gpt-5.6-terra, medium reasoning) × 3 rounds, against four other harnesses (OpenCode · Codex CLI · omp · pi). Every task is judged by hidden tests, on the same account, with no user settings on any of them.

Suite What it measures Aetox Best of the others
CWEval func-sec@1 Functions that both work and survive the attack tests (of 15) 93.3% (Luna)
97.8% (Terra)
omp 68.9%
OpenCode · omp · pi 77.8%
SlopCodeBench % tests passed Six multi-turn tasks, checked so old code does not break 91.6% (Luna)
95.2% (Terra)
OpenCode 90.8%
OpenCode 92.8%
SlopCodeBench checkpoints complete Checkpoints whose tests all pass, of 14 4.0 / 14
7.0 / 14
OpenCode 3.7
OpenCode 6.7
SWE-bench Multilingual (caddy-6350) A real bug from a public repo, official grading 1/3 rounds (Luna)
2/3 rounds (Terra)
OpenCode 2/3
pi 3/3
Web-Bench Tasks whose Playwright spec fully passes, after 6 tasks 5.3 / 6
5.3 / 6
pi 5.3
omp · pi 5.7

The CWEval lead comes from the security skill that ships switched on — with it off, Aetox lands in the same range as the others. And SWE-bench is the suite we do not win, which is already in this table.

Documents and media — measured on the same app, skills on against skills off

  • Thai slides: 98 against 49 with the skill off
  • A video take: 17.5 s → 11.1 s, four silences folded and one filler cut, still editable
  • Teams: the main agent's context 107k instead of 190k · the whole system measured
  • It learns you: of 16 lines the agent proposed about its owner in three days, 4 were kept and all four were about the person; 0 of 8 proposals about the machine survived. That is the bar being applied, not a feature being advertised.

All of it is published, prompts and tests included: the latest coding report · skills on and off · all reports

How to use it well

Aetox has no magic that makes a model smarter — it squeezes the model's capability through architecture. Being able to build a large system on a small model comes from that, and because of it choosing the right model for the job matters just as much.

Our context architecture does not start from the question "how do we save tokens", but from "what does the model actually need to know this round". What the system knows is mapped into a structure of its own — grouped into categories, held as nodes linked to each other — and a run sends only the points a job touches. The prompt is assembled per job, never handed over whole at the start, and nothing is processed that the job does not need: your profile does not ride along on unrelated requests. Memory, skills and MCP all sit under that one architecture.

A skill's body and a tool's schema are never sent up front. The model sees a shelf of names and pays for a body only when it opens one, so fifty skills cost what five cost, and adding an MCP server adds names, not a whole set of schemas. Every agent can take its own skills and servers, separately.

Where a job needs the whole picture we do not make the model ask for it a slice at a time — the breadth is handed over once, up front, and the job finishes in one turn. That is where the tokens go: total input runs 1.1–8.5× the other harnesses, but about 91% of it is cached input, which costs several times less. The real burden is uncached input plus output, and that differs by only 1.1–2.1×: Luna 0.64M against 0.30–0.57M · Terra 0.93M against 0.50–0.81M.

So the extra tokens on some coding jobs are not waste but the side effect of squeezing the model's capability out in exchange for better work, and they do not happen on ordinary jobs — following an instruction, adding an MCP server or installing a batch of skills is handled by the same mechanism, and in real use it comes out surprisingly cheap.

This is the trade worth making, not something to fear. If you want to cut it, cut it by choosing a model that fits the job.

  • Jobs that read a whole project, or run long → the large model has the edge
  • Routine jobs you repeat → the small model is enough, and the system makes up the difference
  • Everything runs on Windows — the screen, the browser and the computer-use layer are all Win32

Rounds swing 1.5–2.5 points, so a gap of a few points reads as a tie · the method and every round are in the report

Inside the box

What it does More
Developer Agent mode works through your project; Editor mode lets you write while it helps. Language servers, Git, a real terminal Code
Assistant Meetings, receipts, research and data become files that open: summaries, Excel, Word, PowerPoint Assistant
Teams Hand a whole job to a ready-made team; see who did what, what each handed over and what it cost Teams
Studio A long video becomes short clips with subtitles you keep editing Studio
Phone Your PC's Aetox on Android or iPhone; keys never leave the PC Phone setup
CLI The Code desk in your terminal, sharing the app's keys, chats and memory Install

The interface ships in English, Thai and Chinese.

Models

31 providers, cloud and local. ChatGPT (Codex), GitHub Copilot and OpenRouter sign in; the rest take an API key or a local server address. LM Studio and Ollama get the same tools as a frontier model. Switch model mid-chat and the whole context comes along.

Pictures can stay on your machine too: point Aetox at ComfyUI or Stable Diffusion WebUI (Forge Neo, Forge or A1111) and it draws on your own GPU, FLUX.2 klein included. Local pictures

Free to use, not free cloud inference. Real work needs a model: an account or key you already have, or a local model. Your provider's pricing applies.

Install

Channel Install Updates
Microsoft Store Store page or winget install --id=9N4KKBRRSCZZ --source=msstore Windows updates it
Installer aetox-amd64-installer.exe In the app: Download the update → Restart to update
Aetox CLI aetox-cli-setup.exe Per user, no admin rights, adds itself to PATH
Scoop scoop install https://raw.githubusercontent.com/Mikedev115/Aetox/main/scoop/aetox.json scoop update aetox

The installer is not code-signed yet, so Windows may show "Windows protected your PC": choose More info → Run anyway, or use the Store build, which Microsoft signs. Portable zip, antivirus notes and what to do when an update does not take: the update guide.

Safety and your data

  • Your data stays on your machine — chats, files, browser data and everything it has learned live on your disk; no server of ours in between and no analytics. A cloud provider sees what its API normally sees.
  • Keys are locked to your Windows account and stripped from logs and tool results.
  • You choose how much it may do — Ask · Unsafe only · Full access. Publishing anything outside and stopping programs by name are asked about at every level.
  • Secret files are refused — .ssh, .aws, Windows credential stores, browser profiles and Aetox's own key files cannot be opened by any tool.
  • What enforces it — these rules are checks inside Aetox's own code, not an operating-system sandbox. For a machine with data you cannot lose, give Aetox an API key of its own and run it in a VM or Windows Sandbox.

Safety in detail · Found a security problem? SECURITY.md says how to report it privately.

Source, licence and who makes it

Aetox is free to use and is not open source. Install it on as many machines as you like and use it for commercial work; do not modify, redistribute, rebrand or sell it (LICENSE). Skills, agents, prompts and MCP servers you write are yours, and selling them is permitted (§4). The source in this repository stops at v1.7.0 and stays here to read and audit. Later releases ship as binaries only, so the version you run has no source to read; what you can check without it. Each release lists the SHA-256 of every file in checksums.txt, signed with the app's update key, and releases built after 21 Oct 2026 also carry sbom.txt: every Go module and web package built into it. The Go part can be checked against the binary itself with go version -m aetox.exe. The Microsoft Store build is signed by Microsoft.

Aetox is written by one person. The community lives in the Facebook group — questions and ideas go there. News and release announcements go to Discussions and Releases. Bugs: issues — Settings in the app prefills one with your version and a log with secrets already stripped. ❤️ Support the project


© 2026 Chayapol Promsavana · All rights reserved · Licence · Third-party notices