tools for autonomous agents, local inference, and verifiable code

An operational dialect and offline linter applying Japanese topic-comment grammar structure to English vocabulary. Standard conversational models burn tokens on polite filler, discursive preamble, and unsolicited questions. This chatter clutters agent traces and degrades reasoning stamina during multi-step coding. We created Progen to compress operational statements into dense, machine-parseable data streams (.prg), enforcing clean separation between operational logic and human interaction.

• Topic-Comment Grammar: Every operational statement asserts topic : comment per line, separated by a single blank line, declaring raw predicates directly with zero filler verbs.
• Syntax and Slack Boundary: agent syntax enforces strict topic-comment structure for internal reasoning and execution; human slack allows informal, natural human prompts.
• Canonical State Vectors: Declares operational intent using canonical heads: intention, requirement, course of action, end result, reason, demand, and compliance.
• Deterministic Truth: Exit code zero is passing. Blocked execution emits ERROR. An unverified or empty check emits DONT_KNOW.
• Offline CLI Tooling: Python CLI utilities to parse topic-comment units into structured JSON, lint outputs against grammar anti-patterns, rewrite text into syntax, and emit reference prompts.

Requires Python 3.10+. Standard library only, zero third-party dependencies:

# clone and install in editable mode:
$ git clone https://github.com/erastudil/progen.git
$ cd progen
$ pip install -e .

# run language conformance self-check:
$ progen check

# lint agent output against topic-comment grammar:
$ progen lint examples/syntax.md --role agent

# rewrite conversational prose into topic-comment syntax:
$ progen syntax examples/mush.md

# emit reference genome prompt:
$ progen prompt genome

source: github.com/erastudil/progen

Zero Context Agent Behavioral Scaffolding is a deterministic proof-of-execution canary protocol and test runner wrapper. Language models predict text by matching statistical patterns in prior tokens. In autonomous agent loops, models frequently hallucinate success or fabricate passing test logs without running any shell commands. We built zcabs so proof of execution requires genuine physical work: the host mints a dynamic integer stored in an isolated canary file. The agent cannot guess or scrape the token; it can only obtain it when zcabs wrap executes the test command, verifies exit code zero on real hardware, and rotates the canary store.

• Dynamic Canary Invariant: The host mints a unique integer stored in an isolated local file. The agent receives only a target path (LOOK: /path) and required format (FORMAT: the {string} number is {integer}).
• Unfakable Hardware Proof: To prove completion, the model must read the target file from disk and report the live integer. Guessing, static scraping, or reading an empty path fails closed.
• Command Wrapping: zcabs wrap -- pytest -q executes any shell command. On exit code zero, it rotates the canary capability and emits the verification header.
• Repository Scanning: zcabs scan . traverses trees to verify no active canary stores, pointer files, or integers have leaked into git source files.
• Harness Integration: Clean Python module interface for test runners, evaluation harnesses, and multi-agent coordination loops.

Requires Python 3.10+. Standard library only, zero third-party dependencies:

# clone and install in editable mode:
$ git clone https://github.com/erastudil/zcabs.git
$ cd zcabs
$ pip install -e .

# run protocol self-check:
$ zcabs check

# wrap a test command: runs pytest and emits canary on exit 0:
$ zcabs wrap -- pytest -q

# scan repository to detect leaked store integers:
$ zcabs scan .

source: github.com/erastudil/zcabs

Greene Feynman Clarity is a prose writing standard and offline linter for human-facing documentation, essays, and educational materials. AI text generators default to tired habits: introducing technical jargon before explaining physical mechanics, copying user prompts into headings, latching onto a single metaphor for an entire page, reciting disclaimers as substitutes for truth, and chaining em dashes. We created GFC to formalize the pedagogical principles of physicists Brian Greene and Richard Feynman: intuitive physical mechanism first, technical label second, state the surviving claim once, contain analogies to single paragraphs, and maintain silence over hedging.

• Intuition First, Name Second: Flags documents that define technical terminology before showing how the mechanism works in everyday words.
• Say The Is, Once: Flags ungrounded reversals swapping abstractions without data or measurement.
• Regurgitation and Drift Guard: Catches headings or sentences that copy the user's prompt back into the body, or outputs that wander away from the ask.
• Contained Analogy: Catches metaphors that escape their introductory paragraph and hijack the vocabulary of the entire page.
• Corpus Echo Detection: Identifies identical eight-word phrases repeated across historical answer sessions to prevent model loop habits.
• Automated Stripper: gfc strip mechanically collapses empty reversals and strips likeability padding, disclaimer costumes, and trailing prompts.

Requires Python 3.10+. Standard library only, zero third-party dependencies:

# clone and install in editable mode:
$ git clone https://github.com/erastudil/gfc.git
$ cd gfc
$ pip install -e .

# run test suite and fixtures:
$ gfc check

# lint human-facing markdown documentation:
$ gfc lint docs/

# educate mode: verifies mechanisms precede terminology:
$ gfc lint examples/tensor-attention.md --mode educate

# strip conversational padding and empty reversals:
$ gfc strip draft.md

source: github.com/erastudil/gfc

A defensive hardening and security refactoring benchmark for autonomous coding agents. Existing benchmarks only test whether an agent can write a greenfield function or solve a textbook puzzle. In production, developers inherit messy legacy systems riddled with backdoors, misleading developer comments, and brittle business logic. We created Tankbench to test agents on real-world defensive engineering: agents receive Harbor Ledger 2.4, an invoicing web application full of 24 obfuscated security vulnerabilities. To score, the agent must eliminate all vulnerabilities while keeping 100% of staff login, invoice search, and financial reporting functions alive.

• Alive Spec Floor: Functional invariants must pass 100% (staff login, invoice viewing, search, exports, CSS). Dodging attacks by deleting routes scores an immediate 0.0.
• Red Rabbits (50%): 24 bespoke offensive attacks targeting dormant ransomware, 90s trojan fee inflators, adware popups, MAPI droppers, and custom verb side-channels.
• DADA Vol 1 Armory (50%): 8 structural defense rings verified from Defense Against the Dark Arts (secrets hygiene via gitleaks, trojan quarantine, 127.0.0.1 socket isolation, Presidio egress PII DLP filters, and strict CSP headers).
• Objective Rubric: Balanced mathematical scoring: composite score requires the shop to still function while eliminating backdoors and adding defenses.
• Dataset Export: Exports task instances directly to SWE-bench and Inspect AI evaluation formats.

Zero setup required. Run baseline calibration or grade a patch:

# clone benchmark repository:
$ git clone https://github.com/erastudil/tankbench.git
$ cd tankbench

# verify baseline calibration (alive pass, probes hit -> score 0.0):
$ python run.py baseline

# grade an agent solution patch file:
$ python run.py grade --patch solution.patch

# generate interactive visual html report:
$ python run.py report --overlay fixtures/hardened --open

# export benchmark dataset for swe-bench / inspect ai:
$ python run.py export --format swe-bench --out task_swe.json

source: github.com/erastudil/tankbench · armory: dadavol1.vercel.app

Defense Against the Dark Arts Volume 1 is the tactical field manual for solo software engineers building with autonomous coding agents and overnight background daemons. Running autonomous agents unattended presents physical hazards to codebases and developer machines: dirty checkouts, unverified third-party dependencies, leaking credentials, runaway token costs, and unmerged side branches. We wrote dadavol1 to document concrete operational fences: bounding checkouts with git worktrees, isolating network sockets to 127.0.0.1, setting hard token and runtime ceilings, and establishing deterministic merge gates.

• Bound the Checkout: Isolate worker checkouts into ephemeral worktrees to prevent dirty git writes and race conditions during concurrent runs.
• Bound the Token: Enforce strict per-turn and per-session token limits to prevent runaway model spend.
• Bound the Merge: Require deterministic verification gates and clean branch integration before code reaches production trunk.
• Machine-Readable Formats: Published in plain text at llms.txt and agent.txt for instant agent consumption.

Read online in browser or feed directly into an agent:

# 1. read interactive manual in browser:
# visit https://dadavol1.vercel.app/

# 2. inspect machine-readable llms.txt:
$ curl -s https://dadavol1.vercel.app/llms.txt | head -n 30

# 3. load raw agent instructions:
$ curl -s https://dadavol1.vercel.app/agent.txt

manual: dadavol1.vercel.app · text: llms.txt · agent: agent.txt