Sight for AI agents. An agent cannot look at a screen — and almost
everything creative software asks a human to look at is actually a
measurable property of the data. AISight is a family of five
independent tools, one per domain, that replace looking with measuring:
deterministic builds, exact reports with where and try: on every
finding, and renders only as evidence for what the numbers found.
| tool | domain | replaces | docs |
|---|---|---|---|
| solidsight | 3D design / CAD / 3D printing | eyes on a viewport | README |
| animationsight | animation clips, mocap (.bvh) | watching the take | README |
| texturesight | UVs + texture maps | squinting at a checker | README |
| shadersight | materials/BRDFs + node graphs | rendering a sphere | README |
| pcbsight | PCB layouts (.kicad_pcb) | eyeballing copper | README |
Each tool is its own pip package: install one, some, or all. They share a philosophy, not a dependency — none requires another.
One tool, from PyPI:
pip install solidsight
pip install animationsight
pip install texturesight
pip install shadersight
pip install pcbsightAll five in one line — aisight depends on every tool, so it pulls
the family in, and is also the command that takes it back off:
pip install aisightThe unreleased main, or a checkout you are editing:
pip install "git+https://github.com/VortexJer/AISight#subdirectory=solidsight"
# or
git clone https://github.com/VortexJer/AISight && pip install ./AISight/solidsightRequirements: Python >= 3.10, pip, git. solidsight carries the heavy dependencies (manifold3d, trimesh, scipy, matplotlib — all wheels); the other four need only numpy and pillow.
The same five tools are also a plugin marketplace. In Claude Code:
/plugin marketplace add VortexJer/AISight
/plugin install solidsight@aisight
The plugin carries the skill; the skill still needs the CLI it drives,
so pip install solidsight as well. Installing the pip package alone is
enough — it self-installs its skill (see below); the plugin route exists
for people who manage their agent's capabilities through /plugin.
aisight status # what is installed on this machine
aisight uninstall # every skill, every package, the marketplaceIt removes the five skills from ~/.claude/skills/, pip-uninstalls the
packages, drops the aisight marketplace from
~/.claude/plugins/marketplaces/ and its registry entry — and then
itself, last. --only <tool> limits it to one tool, --dry-run prints
the list without touching anything, --keep-packages keeps pip.
A git checkout is yours, not ours, so it is never guessed:
--repo PATH deletes one, and only after checking the directory really
is an AISight working copy. Each tool also keeps its own
<tool> uninstall (that tool's skill + package). Details:
aisight/README.md.
Every tool ships its Claude Code skill inside the pip package. The
first time its CLI runs on a machine that has Claude Code (~/.claude
exists), the skill installs itself into ~/.claude/skills/<tool>/ and
keeps itself updated on version changes — from then on, any new agent
session routes matching requests to the tool ("design a bracket" ->
solidsight, "review this .bvh" -> animationsight, "check my board" ->
pcbsight). No Claude Code? The CLIs work standalone for humans and
scripts; nothing else is touched.
<tool> uninstall removes that tool's skill and package; aisight uninstall removes all of it at once (above). No telemetry, no services,
no accounts.
showcase/ takes Vigía, a desk robot, from nothing to
a printable enclosure, a routed controller board, a simulation-ready
URDF, a textured game asset, validated materials and a reviewed servo
gesture — entirely by an AI agent, entirely through measurements. The
enclosure does not copy the board's dimensions: it imports pcbsight
and reads them from the .kicad_pcb, so the standoffs sit at the
board's own mounting pads.
Every stage caught real defects the agent could not see — 31 board findings (both USB nets open with swapped ends), five enclosure iterations (servos placed where the servo headers are, a neck ring floating over the open shell), a flipped UV island, a boosted copper emitting 53% more light than it receives, a stepped servo profile demanding 3600 deg/s of a 600 deg/s servo — and every fix ends in a diff that proves it.
the assembly with its electronics as X-ray ghosts · the board pcbsight took from 31 findings to 0 · the boosted-vs-physical copper · the robot performing its servo gesture
Full narrative and the defect scoreboard: showcase/README.md.
Five hero examples run the same experiment: a cold-context agent with no tools at all (numpy/PIL/trimesh, no viewer, one shot) attempts a hard commission; the same commission then goes through the tool's loop. The blind sides are genuinely competent — the defects they ship are the ones nobody can see without measuring:
| study | blind | after |
|---|---|---|
| engine block (solidsight) | 8 sealed water-jacket pockets (two of 37 cm³), cap bolts 1.9 mm from the crank tunnel, oil gallery 3 mm from coolant | the loop caught the author's own 4 equivalent mistakes, each fixed to a measured wall |
| parkour vault (animationsight) | a 0.47x g stride, root on rails in the turn, a knee pop at landing | OK — 0 findings, every flight at 1 g |
| hero crate (texturesight) | 148 flipped UVs (FAIL), 7.35:1 stretch, 54x density spread | 0 flips, 1.005 anisotropy, 3.35x |
| material set (shadersight) | 8/8 conserve — the one FAIL was the tool's own estimator noise | tool fixed + graph 436 → 204 ALU/px |
| rover board (pcbsight) | 12 open nets, 26 clearance faults | routed: OK — 0 findings |
Left: blind. Right: through the loop. Same commission, same author competence — the only variable is being able to measure.
the inline-4 engine — blind: watertight, single shell, shipped convinced of success; the audit then found eight sealed water-jacket pockets no coolant can ever reach, cap-bolt drillings 1.9 mm from the crank tunnel, and the 2 mm sliver the author itself predicted it might leave · through the loop: the author made the same kinds of mistakes — the loop caught all four
the parkour vault — blind: a 0.47x g stride, a turn step on invisible rails, a knee pop at the landing · after: every flight at 1 g, 0 findings
how to read a UV picture: the flat shapes ARE the crate's surface peeled onto the texture (same colour = same piece — a box unfolded into its cardboard template)
the hero crate's UVs — blind: 148 flipped faces (red), 7.35:1 stretch, 336 stacked islands · after: same geometry and maps, mapper rewritten — 0 flips, welded shells, 92% packing
what shadersight is for: the "boosted highlights" copper emits 1.7x the light it receives (curve far above the red ceiling) yet its preview sphere looks almost identical to the physical one — the eye can't audit energy. The blind-vs-measured study's twist: the blind author knew its F0s and refused the boost bait; the one FAIL was the tool's own estimator noise on an exact-F0 gold, fixed at 16x sampling.
the rover board — blind: 12 open nets, 26 clearance faults circled in red · after: routed, 0 findings
Each README credits what the blind side got right, ties every fix to a measured finding, and lists the bugs the studies forced back into the tools themselves.
- Known ground truth: every example is synthetic on purpose, with defects injected at exact magnitudes, so the tests assert the right answer — and that the clean reference stays clean, because false positives are how a tool loses the right to be believed.
- Deterministic: same input, byte-identical report; fixed seeds where sampling is involved, resolution stated in the report.
- The full loop: inspect -> fix -> diff to prove the fix did what you meant and nothing else.
- Honest scope: each README lists what is NOT read or checked.
The family overview — and the bugs each tool caught in its own reference, which is the recurring proof of the whole idea: docs/roadmap-sights.md.
solidsight/ 3D design: engine + CLI, skills/ (+ domains/), examples, benchmarks
animationsight/ motion clips as measurement
texturesight/ UVs + texture maps
shadersight/ materials + node graphs
pcbsight/ board layouts
aisight/ the family command: status + one clean uninstall
showcase/ Vigia: one robot through all five tools (the flagship demo)
docs/ the blind-vs-loop comparison study, plugins, family roadmap
Each tool folder is self-contained: pyproject.toml, the package, its
skills/<tool>/, examples/ with committed real outputs, and
tests/.
MIT