live agent build · business problem defined

BUILD BIGGER,
BUILD MORE.

From synthetic data and mimic operators to token routing and recursive self-improvement.

ASHAYA SHARMA

export bios talk.pptx

Blue dither illustration of Science World, Vancouver

live agent build BIOSSPHERE.ASHAYA.XYZ

01 · past month of builds

“I’VE CLANKED OUT
A LOT OF RANDOM
STUFF.”

macOS agent buddy lists, 100Hz MEMS motion cues, Rust Cloudflare Workers, and self-hosted MCP bridges.

KEY TAKEAWAY AXIOM 01

VOLUME CREATES INTUITION.

Shipping across domains reveals a repeatable agent build loop.

ashayas/asimessenger

macOS buddy list for Claude, Codex, OpenCode & Gemini.

ashayas/whatchureading

Reading app · Rust Cloudflare Worker API + D1.

ashayas/macdots

100Hz Apple Silicon MEMS motion cues.

ashayas/tweetstream

Self-hostable X REST API & MCP server.

Multi-Agent Board + Ghostty+

Collaborative agent sessions + GPU terminal.

step 01 · data first

START WITH DATA. IF IT DOESN’T EXIST, CREATE IT.

The business problem is defined. Step one is building the dataset and eval set.

DAY 0 BOOTSTRAP 01

MODELS CREATE SYNTHETIC DATA

Have frontier models generate realistic inputs, edge cases, and grading rubrics on Day 0.

agent.synthesize_eval_cases(
count=250,
personas=["adversarial", "noisy"]
)

WATCH OUT 02

SYNTHETIC DATA PITFALLS

[!] MODE COLLAPSE: Inputs are too clean and polite.
[!] SELF-BIAS: Models overfit to their own phrasing.
[!] BLIND SPOTS: Misses real production timeouts and weird state.

FINAL STAGE 03

PIPE IN REAL DATA

Start with synthetic data now. Replace it with real production usage traces at the final stage.

SYNTHETIC BUILDS THE TRACKS.
REAL DATA DRIVES THE TRAIN.

step 02 · defining the agent process

HARNESS GOALS: MODELS AS MIMIC OPERATORS

Let the model do most of the work. Give it tools and point it at something that works well.

DEFINITION // MIMIC OPERATOR CORE

MODELS ARE NATURAL MIMIC OPERATORS.

Instead of writing brittle rules, point the model at a working reference repo, handler, or golden trace to mimic.

MIMIC SETUP:
01 // Point at a gold-standard exemplar
02 // Give full tool access (shell, files, search)
03 // Grade the outcome against the Eval Set

GOAL 01 AUTONOMY

LET THE MODEL DO THE WORK

Give it raw tools and let it iterate in its native loop.

GOAL 02 EXEMPLARS

POINT AT WHAT WORKS

One golden example beats pages of negative constraints.

GOAL 03 LOCKED

EVAL SET + PROCESS READY

With the Eval Set and Agent Process locked, we optimize deployment.

step 03 · deployment & token efficiency

SAVING TOKENS: DIFFICULTY JUDGES & SUBAGENTS

Judge task difficulty upfront, use heavy models sparingly, and spin up subagents on demand.

DIFFICULTY JUDGE 01

JUDGE TASK DIFFICULTY

Score task complexity upfront and offload to the matching model tier.

easy -> fast_flash_model
medium -> standard_worker
hard -> frontier_reasoner

SPARING USAGE 02

USE MODELS SPARINGLY

Reserve frontier reasoning for hard synthesis. Route lookups and parsing to smaller models.

60 TO 80% TOKEN SAVINGS.
ZERO DROP IN QUALITY.

SUBAGENTS 03

SPIN UP SUBAGENTS

Spawn isolated subagents to finish subtasks and return only distilled results.

spawn_subagent(
task=subtask,
model=judge.route(subtask)
)

step 04 · closing the loop

RECURSIVE SELF-IMPROVEMENT VIA RECURSE.PY

All recursiveness runs directly inside the coding agents.

PHASE 01 RANDOM RUNS

RUN RANDOM EPISODES

Trigger random runs on the agent to surface edge cases and failure modes.

PHASE 02 EVAL HARNESS

ADD LIKES & DISLIKES TO EVALS

Every liked or disliked run automatically appends to the Eval Harness.

PHASE 03 AGENT HARNESS

POINT AGENT AT EVAL HARNESS

The Agent Harness points directly to the Eval Harness while the coding agent iterates.

EXECUTABLE // RECURSE.PY INSIDE CODING AGENT

# recurse.py (runs inside coding agent)
for run in random_runs(agent_harness):
    res = eval_harness.grade(run)

    if res.liked or res.disliked:
        eval_harness.add(run, res)

    coding_agent.improve(
        target=agent_harness,
        verify=eval_harness
    )

The coding agent reads failure traces and patches the agent harness against the live eval harness.

what goes wrong

MISTAKES WHEN BUILDING AGENTS

Three traps that nerf frontier models in production.

01

Instructing Too Much

Over-steering nerfs models

Over-instructing nerfs frontier capabilities. Do less low-level micro-steering and more high-level business-process steering.

02

Missing Review Flow

Human-review vs. auto

Give the agent a controlled flow to mark high-risk items for human review and enlist routine tasks as non-reviewable.

03

Neglecting Classical ML

Agent-built classifiers

Have the coding agent build a lightweight classifier or smaller model to handle sub-tasks at a fraction of the cost.

contrary to popular belief

PROMPTING STILL KIND OF MATTERS

The agent will figure it out, but sharp prompting saves tokens and aligns tradeoffs.

01 // TOKEN COMPRESSION PROMPTING

PROMPTING SAVES TOKENS

Agents can brute-force vague prompts, burning thousands of exploration tokens.

USE EXACT REFERENCES:
Naming terms like "fault-resistant" or exact file paths collapses 20 search turns into 1.

-> Then I start reading the plan.

02 // DO YOU READ THE CODE? TRADEOFFS

NOT INCORRECT, JUST MISALIGNED

We read less boilerplate now, but agents make silent architectural tradeoffs.

WHY REVIEW STILL MATTERS:
The code is rarely broken. Instead, it may make fundamental tradeoff decisions that don't match your system goals.

compounding system memory

TWO SELF-IMPROVING LOOPS + REAL DATA

One loop improves the runtime agent. A second loop improves the harness building the agent.

LOOP 01 // RUNTIME AGENT AGENT

.AGENTIC/ FOLDER

Self-improving loop for the agent itself: stores plans, mimic exemplars, and recurse.py evals.

.agentic/
├── eval_harness.jsonl
├── mimic_exemplars/
└── recurse.py

LOOP 02 // BUILDER HARNESS HARNESS

.MISTAKES/ FOLDER

Logs mistakes the coding agent made so the builder harness learns and never repeats them.

.mistakes/
├── over-steering.md
├── schema-tradeoffs.md
└── sandbox-leaks.md

THE FUEL // REAL DATA PIPELINE

KEEP FEEDING REAL DATA

Pipe live production usage traces into both loops to continuously upgrade accuracy.

USAGE PIPELINE -> UPGRADES BOTH LOOPS.

Multiplayer Git Tree vs Single-Source Stacked Agent Flow

verification gates

STRESS-TESTED SANDBOXES

Autonomous loops only work when the sandbox matches reality under load.

GATE 01ISOLATION

CLEAN WORKTREES

Isolated state per stacked issue.

GATE 02TYPES

FAST COMPILER

cargo check / tsc in milliseconds.

GATE 03PARITY

LOCAL RUNTIME

Real local D1 & Worker parity.

GATE 04LOGS

SESSION LOGS

Grep-searchable .boards/session.log.

UNVERIFIED SANDBOX BROKEN SIGNAL

PHANTOM GREEN BUILDS

Mocked DBs and shared state trick recurse.py into optimizing for false positives.

STRESS-TESTED SANDBOX GROUND TRUTH

DETERMINISTIC FEEDBACK

Load testing and real bindings feed actionable failures into .mistakes/ and the Eval Harness.

and there you have it