aict Review 2026: Unix Coreutils With Structured Output So AI Agents Stop Parsing Plaintext

AI coding agents spend a surprising amount of their budget not on thinking, but on re-reading what they just ran. When an agent calls ls -la or grep, it gets back columns designed for human eyes — and then burns tokens guessing which column is the file size, whether a line is a directory, or what timezone a timestamp is in. aict is a small Go CLI that attacks exactly that waste. It reimplements 33 Unix tools to emit structured XML or JSON instead of human-formatted text, so an agent can read a file listing, a search result, or system state with zero parsing.

The pitch is simple: every field is labeled, every path is absolute, and every timestamp is a Unix integer. The model gets the data it needs without the fragile “figure out the column width” dance. And because aict ships a built-in MCP server, those tools show up as first-class, schema-described functions inside Claude Code, Cursor, or Codex — no wrapper code and no separate service to keep alive.

What aict Does

At its core, aict is a drop-in replacement for the coreutils an agent reaches for constantly — ls, grep, cat, find, ps, du, and about two dozen more. Instead of printing -rw-r--r-- 1 user staff 2048 Apr 6 10:00 main.go, aict ls returns a labeled tree where size_bytes, language, mime, binary, and absolute are explicit fields. An agent that needs “the Go files over 1KB modified this week” can filter on real attributes instead of regexing the ls output.

It is deliberately scoped: aict does not try to be a shell, a task runner, or an agent framework. It is one binary that makes the inspection commands agents already call return machine-readable answers. The README even includes a token-cost section and benchmarks, because the entire point is to remove a recurring parse-and-guess loop from every command an agent runs.

Use Cases

• Unattended coding agents that fire off many ls / grep / find calls per task and currently waste tokens stabilizing the plaintext before they can reason about it.
• Claude Code / Codex workflows where you wire aict mcp in once and let the model call structured tools instead of shelling out to GNU coreutils.
• Cross-platform agents that break today because ls on macOS and Linux (and grep with BSD vs GNU flags) format output differently — aict gives one stable schema everywhere.
• Token-constrained runs where every saved parse step compounds across a long session into real cost reduction.

Key Features

Agent-native structured coreutils

33 reimplemented tools emit labeled XML/JSON: absolute paths, integer Unix timestamps, auto-detected language and MIME, size in both bytes and human form. Nothing to guess, nothing to split on whitespace.

Built-in MCP server

aict mcp exposes every tool to Claude, Cursor, and Codex over Model Context Protocol as properly described functions — no extra server process, no hand-written tool definitions.

Claude Code integration

Point the agent at aict instead of the plain commands and it receives structured output the model can reason over directly, cutting the token cost of re-parsing human formats.

Token-cost aware

The project explicitly targets the tokens and fragility wasted parsing human output, and documents savings and benchmarks in the README rather than hand-waving about “efficiency.”

Easy install

Homebrew tap, go install, or build from source; ships zsh/bash completions. Note it requires Go 1.25 to build from source — a very new toolchain.

Pricing

aict is free and open source under the MIT license. There is no paid tier, no account, and no telemetry. You install the binary (or run the MCP server) and it is yours. The only “cost” is that building from source needs Go 1.25.

Common Questions

Is aict a replacement for my shell? No. It reimplements the inspection commands agents call most, with structured output — it is not a shell, a task runner, or an agent. Humans at a terminal will find the XML/JSON noise; its value is entirely for agents.

Does it actually save tokens? The structured output removes the recurring parse-and-guess loop per command, which is where the savings come from. The README documents benchmarks and a token-cost section, but treat the exact figures as indicative rather than independently audited.

Is it safe to wire into an agent? The MIT license and single static binary make it low-risk to try. The main caveat is that it reimplements coreutils, so behavior can diverge from GNU/BSD in edge cases the originals handle — pin a release and test on your own workloads.

Verdict

aict is a small, well-built utility that solves a real and recurring agent pain: the tokens and fragility wasted parsing human-formatted command output. The built-in MCP server and Claude Code integration make it trivial to drop in, and the MIT license plus active maintenance (latest release v2.2.0, last push 2026-09-01) make it safe to adopt. It will not replace your shell, and the community is still tiny (16 stars, 5 forks), but for anyone running Claude Code or Codex unattended it is a clean, low-risk win. Rating 7.0/10.