Kinetic-AG: rebuilding the foundation

I started Kinetic-AG as a project about using symbolic operations and deterministic grid tools to help an AI reason through ARC-style visual puzzles. Then I left it alone for a while.

Coming back to it, my first priority was to re-ground myself in what the code actually does before adding anything else on top. Some earlier progress reports made the project sound further along than it really was: scanning ARC files and extracting objects is not the same as solving ARC tasks.

Over the past few hours, I’ve been reviewing and hardening K‑VL, the library that handles the grid operations. I fixed a bug where one same-color shape could leak into another shape’s mask, added stricter checks for malformed grids and objects, replaced an expensive distance calculation, and removed Python code execution from the training verifier. I also wrote down the library’s rules and added tests for the behaviors I’m relying on.

This is still a prototype. I haven’t tested it on the ARC‑AGI‑2 tasks; I’m saving those as a later benchmark once the library is more dependable. My next goal is to keep tightening the contracts and tests before I build the model-facing DSL.

It feels good to return to this project with a clearer idea of what “working” should actually mean.

Improved the K-VL library.

Kinetic-AG

A Neuro-Symbolic Program Synthesis Framework for Fluid General Intelligence on ARC-AGI-2.

── Abstract

Current Large Language Models excel at static retrieval and pattern replication, but they fundamentally fail at fluid intelligence—the ability to adapt to novel, unseen problems without explicit training data. The ARC-AGI-2 benchmark exposes this “Overfitting Trap” by forcing models to solve abstract visual-logic grids using fundamental Core Knowledge Priors.

Kinetic-AG is an advanced neuro-symbolic framework designed to bypass the limitations of raw neural pixel-guessing. By transforming a generative model from a predictive writer into an autonomous programmer, Kinetic-AG uses test-time program synthesis and automated code verification to solve multi-step geometric transformations with mathematical certainty.

── The Architecture

Kinetic-AG splits the cognitive load between neural perception and symbolic execution through two core pillars:

1. K-VL (Kinetic Vision-Logic Library)

Instead of forcing the model to write complex NumPy matrix math from scratch—which introduces a high risk of syntax drift and boundary errors—we engineered K-VL, a custom Domain-Specific Language (DSL) embedded in Python.

K-VL maps directly to human Core Knowledge Priors across four specialized modules:

• K_Space: Dynamically manages variable grid layouts, topology, and dimensions.
• K_Objects: Performs connected-component labeling to isolate, categorize, and filter spatial entities by color, coordinate geometry, or size.
• K_Transform: Executes physics-safe translation vectors, clockwise/counter-clockwise rotations, and axial mirroring.
• K_Color: Employs an optimized, graph-based Breadth-First Search (BFS) flood-fill engine for rendering complex painting logic.

2. Test-Time Program Synthesis & Automated Verification

Kinetic-AG does not execute blind predictions on unseen test data. The framework implements a strict runtime execution gatekeeper (verify_engine):

1. Hypothesis Generation: The core reasoning engine analyzes the visual patterns of an active puzzle and outputs a custom Python execution script using K-VL syntax.
2. The Crucible (Sandbox Testing): The framework dynamically compiles the script inside an isolated local sandbox, executing it against all given demonstration pairs (which dynamically scale up to 10 pairs depending on the task specification).
3. Automated Rejection Sampling: If the script fails to match the output matrices of the demonstrations by even a single pixel, it is instantly rejected. The runtime error trace is recycled, and the engine generates a refined hypothesis.
4. Verified Execution: Only when a code block achieves a perfect 100% validation rate across every single example pair does the framework execute the solution on the hidden test grid.

── Engineering Journey & Robustness Testing

Building Kinetic-AG required navigating structural variations introduced in the updated arcprize/ARC-AGI-2 specification, where input spaces, training pair sizes ($\le 10$), and target evaluation counts ($2\text{ to }4$) fluctuate wildly.

To guarantee architectural stability before scaling up computational training loops, we engineered an end-to-end data auditor script. We executed a mass robustness sweep across the entire official dataset, running thousands of extraction passes.

The Result: The K-VL pipeline achieved a perfect, crash-free stability rating across the multi-grid structures of the dataset, logging every spatial metric into a structured compilation framework (kvl_audit_report.json) to serve as our downstream training profile.