Autonomous · Research · Engineering · Synthesis · Architecture

Autonomous
research engine

Aresalab is the public face of ARESA: agents, experiments, code, writing, and citations in one visible loop. The goal is useful public work from a research system that keeps getting sharper.

3
Papers
2
Books
Loop
● Live
aresa/engine.tsx
const aresa = {
1engine:['idea', 'research', 'build'],
2rig:['test', 'publish', 'learn'],
3outputs:['tools', 'papers', 'books'],
4next:'self-improving loop',
}
~/yore-ai
AI-first
What ARESA means

Autonomous Research Engineering & Synthesis Architecture. The engine, not the slogan.

ARESA is the system I'm building: a practical loop for moving from idea to experiment to useful public artifact.

01
Autonomous

Agents do the legwork: search, draft, run, compare, and prepare the next step.

02
Research

Every idea has to become a question that can be tested, not just described.

03
Engineering

The output is code, tools, dashboards, papers, and the scripts that verify them.

04
Synthesis

The system turns scattered notes, runs, and failures into something readable.

05
Architecture

The loop is designed to repeat, improve, and eventually suggest its own next question.

The ARESA loop

Idea to artifact. Then back again.

The loop is simple: find a real question, build the rig, run it, write clearly, publish openly, then use the gaps to choose the next experiment.

01Idea02Research03Build04Test05Publish06LearnPHASE 2 →ARESAthe loopCLOSED · COMPOUNDING
Idea
Is this worth doing?

Start with a real need, not a topic. If the work would not help someone think, build, or verify better, it waits.

Research
Map what exists

Agents search, compare, and summarize. The human job is to decide what is actually new, needed, and honest.

Build
Make the artifact

The output can be a tool, a benchmark, a dashboard, a simulation, or the rig that will test the claim.

Test
Let reality push back

Run experiments, check the numbers, look for weak claims, and keep the failure cases visible.

Publish
Code, paper, citation

The work ships as a readable page, a runnable repo, and a citation path. Public work should be easy to inspect.

Phase 2
Learn
Next question surfaces

The system reads its own output and finds the next useful experiment. Today the loop is human-closed. Tomorrow it becomes agent-closed.

Phase 1
Shipping now

The loop already produces public work.

The current system helps turn ideas into code, experiment rigs, papers, books, and demos. The outputs are different, but the workflow stays the same.

Phase 2
In design

The loop authors its next question.

Phase 2 is the self-improving step: an agent reads the artifact, checks the claims against the evidence, finds the weakest part, and proposes the next useful experiment.

A working theory
A research lab isn't a list of papers.It's a loop — and the loop learns.
The operator

Built by Yev Chuba, with agents in the loop.

Aresalab is my public research practice: part portfolio, part lab notebook, part publishing pipeline. The point is not to look busy. The point is to show that one operator, using agents carefully, can ship useful public work.

Read the short version
Research

Find the question, map what already exists, and decide if the work is needed.

Experiment

Build the rig, run the numbers, and let the results push back.

Publish

Turn the work into a paper, a tool, a citation, or a public demo.

Improve

Use the gap in the last artifact to choose the next experiment.

What the engine produces

Not random projects. Outputs from one method.

Output 01

Open-source tools.

AresaDB exists because some tools should exist and do not. The lab builds them, tests them, and publishes the hard parts.

Output 02

Verifiable research.

Papers ship with the scripts behind the numbers. If the experiment cannot be rerun, the claim does not belong on the page.

See the rigs
Output 03

A public operating record.

Books, papers, demos, failures, and citations become one visible trail of how the research engine is improving.

Proof so far

Papers and tools

All papers
AGENTS2026-04

Mars Colony Simulation

A two-layer architecture for studying emergent collaborative behavior in multi-agent LLM systems. A deterministic rule substrate governs agent needs, pairwise bond dynamics, action selection, and a hard cost ceiling; an LLM-powered dialogue module (GPT-4o-mini / Claude Haiku) sits on top. Reproducible claims ship as experiments/run.py — stdlib Python, ~3 seconds on an M2 Pro. Across 10 seeds × 10,000 ticks we observe 3.5 ± 2.8 strong friendships, 14.6 ± 2.3 working relationships, and 3.6 ± 1.6 tensions per session, with 100% of construction sites completing (7.3 avg unique workers per site) and a 49.2% work-dominated action distribution. Cost ceiling is $0.007 per session by construction.

3.5 ± 2.8
Strong Friendships
3 / 3
Construction Sites Done
7.3
Unique Workers / Site
Read paper
DATABASE2026-04

AresaDB Technical Report

AresaDB is a high-performance, multi-model database engine written in Rust that unifies key-value, graph, and relational data paradigms under a single property graph foundation. Every cited number is reproduced by a single script in the repo. Measured on a 50K-node, 250K-edge, 10K-vector workload (macOS aarch64, April 2026 re-run against v2.0.0-alpha.2): batch insert exceeds 75,000 nodes/sec (≈258× over single inserts), point lookups land at ~5 µs p50 / 14 µs p99, HNSW search completes in ~7 µs (≈103× over brute force), and B-tree secondary indexes deliver ~23× over full-scan queries. A distributed v2 cluster (multi-Raft, range-partitioned, pluggable redb/fjall backends) is in alpha alongside this paper and is covered by a separate write-up in the same repository.

5 µs (p50)
Point Lookup
75K/sec batch
Insert Rate
7 µs (HNSW)
Vector Search
Read paper
ARCHIVED2026-04

Fire Safety Dashboard

A reproducible audit of 550,145 fire-department dispatch records from Allegheny County (2015-2025), of which 367,444 are fire-specific. Fire alarm activations dominate the workload at 205,398 incidents (37.3% of all calls, 55.9% of fire-specific), and commercial properties account for 64% of those alarms — implying a bounded annual cost of roughly $131.5M at $1,000 per response. Structure fires peak in Winter (heating-driven) while outdoor fires peak in Spring (vegetation-driven). Every number in the paper is regenerated by experiments/run.py from the same JSON aggregations used by the archived dashboard.

550,145
Records Audited
205,398
Fire Alarms
64.0%
Commercial FA Share
Read paper
Long-form thinking

Books and notes

All books
M
2024, revised 2026
10 chapters

Mathematical Awakening: Connecting the Equations of Nature and Intelligence

A long-form pass through the mathematics ML engineers actually use: calculus, linear algebra, probability, and statistics, with worked examples that connect classical physics to modern machine learning. The 2026 revision preserves the original Chapters 1-8 and refreshes Chapters 9-10 to cover rotary position embeddings (RoPE), grouped-query attention, flash attention, scaling laws, GRPO, and diffusion / flow matching, closing with a reading walkthrough of the DeepSeek-R1 paper. Python snippets are embedded throughout to visualise concepts and show how the math maps to code you'd recognise from PyTorch or NumPy.

Open book
A
2026
1 chapter

Applied ML 2026: Reproducible Projects for the LLM Era

An in-progress companion volume to Mathematical Awakening, being written from scratch in the LLM era. Each project ships with a reproducible rig (experiments/run.py → metrics.json) in the tradition of the rest of the Aresalab papers: LLM-first patterns (retrieval, tool-use, evals, distillation, quantisation), domain depth (healthcare, bioinformatics, robotics), and honest failure modes. Published chapter-by-chapter as each project lands with a running experiment.

Open book
P
2024
3 chapters

Applied Machine Learning: 25 Worked Projects Across Healthcare, Bioinformatics, and Vision/Robotics

A 2024 snapshot of 25 worked ML projects across three domains: healthcare and medical AI (10), bioinformatics and genomic AI (8), and computer vision and robotics (7). Each project ships a problem framing, a pointer back to the underlying math in Mathematical Awakening, an architecture choice, an implementation sketch, and a short list of failure modes to watch. Code listings are static; datasets are cited by source and license, not vendored. Archived in the 2026 bookshelf refresh — the successor volume Applied ML 2026 is being written from scratch for the LLM era, with a reproducible rig per project.

Open book
Start here

Two practical doors.