From one solution to a reusable skill.
a2 is a small Python agent that solves data transformations, checks results externally and investigates reusing accepted solutions as versioned executable skills. Explore its source, workflow, demo and evaluation records in one place.
Why a2?
Solving a task once and safely reusing its solution on different inputs are different problems. a2 investigates that gap through a small, inspectable agent loop. Its initial domain is bounded data transformation: record normalization, source matching, conflict detection and field projection.
- Start with the contract.
- Make inputs, outputs and rules explicit. A correctly shaped output is not necessarily a correct answer.
- Check independently after solving.
- A skill candidate derived from a successful answer is tested on different inputs against expected results kept outside the model conversation before persistence.
- Reuse has boundaries too.
- The contract and skill version must match. If the code behind a reviewed plan changes, execution does not silently substitute another version.
A task’s journey
Four responsibilities around a small core
Base + Trace
Build context from the goal, prior traces and tool observations; select actions within step and budget bounds.
Gate
Routes risky general-agent tool actions to approval. Approval is not operating-system containment.
Auditor
Separates format checks from correctness checks against independent expected results. Without a reference, schema_only does not establish correctness.
Skills
Stores the accepted skill’s contract, provenance, version, code hash and verification records, with recheck, disable and rollback paths.
From task to inspectable record
Contract and independent expected result
The task owner specifies what the data means and which result is acceptable.
Solution and skill candidate
In the live learning path the model solves the task, then produces a candidate from an accepted solution. The demo substitutes human-written skills.
Verification on separate inputs
At least two distinct caller-owned checks are required before persistence; the built-in data learner uses three separate verification tasks.
Version-pinned reuse
Run a skill directly or in an explicit plan. A model-proposed plan does not execute itself; a version mismatch stops execution.
Output and evaluation record
Report quality, calls, latency and observed tokens separately. Incomplete evaluation does not become a success claim.
This is a workflow map. Not every run traverses every stage: the offline demo and direct skill reuse make no model calls; learning and model-assisted planning are separate paths.
Three concrete uses
- Customer exports from two systems
- Reconcile CRM and ERP CSVs with exact matching on shared unique codes. The synthetic two-day demo shows matched and review-needed records; it has no live system connector.
- Same rule, a new file tomorrow
- Apply a verified projection or matching skill to fresh inputs. An unmatched contract stops without an automatic model fallback; supplied expected results enable a separate correctness check.
- A reviewed plan’s skill changes
- New plans pin skill IDs and code hashes. An unavailable or changed version stops the plan before the first step.
First run
Start with the CRM/ERP demo that needs no model. Get the source in your own local workspace; the setup below targets Linux or macOS and Python 3.11+. This page does not execute the commands.
Download or clone the v0.1.0a1 source tag, create a virtual environment and install the package.
Run the synthetic customer demo into a fresh output directory. No API key or model call is needed.
Open runs/customer-demo/report.html and inspect the plans, matches, issues and skill-version change check.
Local setup from the tag
git clone --branch v0.1.0a1 --single-branch https://github.com/omasim/a2.git
cd a2
python -m venv .venv
source .venv/bin/activate
python -m pip install -e .API-free presentation demo
python -m a2.customer_demo --output runs/customer-demo --compactRun these commands in the same terminal from the source checkout. Choose a new output directory for a repeat run. The demo reuses the same two verified human-written skills on two synthetic batches; it does not demonstrate model learning or real-customer validation. To inspect persistent skills, follow data init --with-demo-skills in the README.
Related writing
What changed before retrying?
A working note from a2 on making the reason for another attempt visible.
Why does a plan refuse to run?
Stopping before execution when a skill version changes in the a2 demo, and the distinction between code identity and correctness.
The same task, a different file tomorrow
Reuse with the same skills, exact-code matching and independent result checks in a two-day synthetic CRM/ERP demo.
a2’s first technical preview
The 0.1.0a1 release: inspectable data workflows, reusable skills and the explicit boundaries of the technical preview.
A task’s journey through a2
A two-record example tracing the contract, execution path, output checks and the record left at the end.
When should an agent stop?
Completion, repetition, shared budgets, uncertain actions and authorization in a2: what must we know before taking the next step?
Turning an idea into a working tool
Through a2: the distance between a verified solution, a reusable skill, and a completed task.
Docs and links
Source and version
Verified tag, source archive and reviewed commit.
Architecture and skills
Core loop, contracts and skill lifecycle.
Getting started and demo
From installation to inspecting synthetic examples.
Experiments and evaluation
Measurement, open gates and the real-pilot protocol.
Contributing and security
CI history, issues, contribution and license.
Publication documents
Preview scope and publication preparation.
Status and limits
As checked on 22 October 2026, the source repository is public, MIT-licensed and tagged v0.1.0a1. Recent CI runs passed. The GitHub Releases list has no separate release entry; the download link points to the tagged source ZIP. A technical preview is not completed general-release acceptance.
The source documents record four independently verified skill families from a bounded live learning run. A small, incomplete development pilot showed no efficiency advantage. Complete frozen multi-seed evaluation and real-user validation remain open. The restricted skill worker is not an operating-system sandbox for arbitrary adversarial Python.
Synthetic demo ≠ model learning. Format checks ≠ semantic correctness. Passing CI ≠ completed user or release acceptance.
This portal uses the public README, architecture, skills, evaluation and publication documents at the same commit as v0.1.0a1. No new model experiment or paid provider call was run. Source documentation is mostly English; the demo guide and some launch materials are Turkish.
Existing project text and dated sources
The editable project record below preserves the earlier summary dated 13 October 2026. Its pre-publication statements are historical; the current source status is above.
Question
Can a successful solution become a skill that can be reused on other tasks? a2 investigates this through data transformation tasks.
Working parts
The small Python agent combines tools, shared memory, output validation and executable skills. Current tasks include normalization, source matching, conflict handling and field projection. Skill candidates produced from successful solutions must pass external checks on independent inputs before being stored.
Evaluation
Frozen learned skills are compared on separate tasks with history-free solving, successful context examples, human-written skills and unrelated skills. Quality, latency, model/tool calls and observed token use are reported separately.
Status and limits
The source reviewed on 13 October 2026 describes a development alpha. The offline demo verifies and reuses human-written skills; it does not demonstrate model learning. A bounded live training run recorded verified skill families, but an incomplete development pilot showed no efficiency advantage. Frozen multi-seed evaluation and real-user validation remain open. Publishing this page does not mean the software package has been publicly released.
Source record
Based on the a2 README, architecture and evaluation documents reviewed on 13 October 2026. No new experiment was run.