Erik Perttu

February 2026 – Present

An autonomous engineering pipeline written in Python that takes a ticket from input to tested, reviewed, committed code with no human in the execution loop. The architecture behaves more like a compiler for LLM behavior than a conventional agent framework: LLMs handle the parts that require interpretation, non-LLM code handles everything that can be computed. The same split isn't specific to coding. It's just the domain with a large enough codebase and enough runs to prove it on.

• Scout and grounding chat: A Scout stage extends the front of the pipeline to raw issues: it derives where a fix belongs and whether it is expressible there under the repo's own constraints, surfacing type-system prerequisites as operator-confirmed inputs before a run starts, so the pipeline begins from a symptom rather than a hand-written specification. A grounding chat then confirms intent, exclusions, and design decisions against the registry, and writes a structured handoff the downstream pipeline reads as the source of truth, not as text to re-interpret.
• Manifest synthesis: Built on a symbol registry and language server integration. A Synthesizer stage compiles planner-authored sub-tickets into builder manifests with no LLM in the conversion: the Planner decides what to build, the Synthesizer resolves and grounds every reference against the registry before any builder runs. Every fact is extracted from the codebase, not guessed, eliminating hallucination surfaces.
• Builder context: Derived separately, from a call-graph walk out of the subject: builders receive the files that walk marks as relevant plus a symbol index over them, so they pull the exact symbols they need instead of searching the tree. Contract obligations are pushed the other way: signatures for every symbol the ticket references are rendered from the registry into the prompt, with a mismatch gate refusing code that contradicts them. A builder asking for an unsupplied file is a hard failure, because an under-supplied model guesses.
• Coder and Test Writer: Specialist agents run in sequence with no shared memory or reasoning between stages. The Coder and Test Writer are LLMs with edit tools working in sandboxed copies of the tree: the pipeline converts sandbox diffs into surgical operations. A rewrite that is not symbol-decomposable is refused on every attempt but the last, with the offending line ranges returned as feedback; only the final attempt may fall back to a whole-file rewrite, still guarded by a byte-level preservation check on untouched symbols.
• Verification: Tests are written before the Coder runs and confirmed failing before implementation starts. Oracles are proven non-vacuous via two gates: confirm-RED (the test must fail while the change is absent, before the implementation exists) and an end-of-ticket mutation gate (derived wrong-version mutants, scoped to the ticket's semantic delta on the abstract syntax tree, must be killed before the ticket closes).
• Debugger router: The Debugger router classifies each failure and dispatches to the stage that owns the fix. Code failures route to the Coder with a corrective brief, planning failures back to the Planner for a re-plan, machine-confirmed ticket contradictions to the operator as a structured correction request. Most end-of-ticket gates route to a fail-safe repair pass that re-runs the gate authoritatively rather than terminating. Gates verify what changed, not absolute health, so a pre-existing problem cannot fail a correct change. It is the only stage that can change where the pipeline goes next.
• Safety and conformance: Structural, not advisory. Hard stops, a write gate that contains scope to the manifest, the project's own linter and pre-commit conventions enforced end-of-ticket (Biome and ESLint for TypeScript, ruff for Python), a guard that terminally fails any run whose builder silenced a checker instead of fixing the violation, and full per-stage trace logging.

Proven on TypeScript and Python codebases, including a ~200k line TypeScript monorepo, and on public open-source Python (a merged-quality pytest-xdist bug fix, suite 220/0), with tests authored and run under pytest, vitest and jest. Current work runs on LoopsBench, Microsoft's published long-horizon coding benchmark, whose hidden tests grade each result from outside the pipeline; two units resolved so far, one Python and one TypeScript. Runs execute against pinned baselines so results are comparable across re-runs. Every run produces a full artifact chain: per-stage LLM reasoning traces, structured manifests, Coder operations, Reviewer verdicts, and per-stage cost and token data. The archive spans ~1,900 runs, including an early 248-run reliability campaign that exposed a hallucination ceiling and drove architectural changes rather than patching prompts field by field.

Each stage has its own model configuration. Model, effort level, and LLM vendor are set independently per agent. Designed to work with any LLM provider. The pipeline itself is developed under TDD.

Still R&D.

January 2017 – Present

Leading technical strategy for Vietnam's largest education review platform, 1M+ MAU. Built and led the engineering team from the ground up: sourced, interviewed, hired, and mentored every engineer. Responsible for technical culture, career development, and engineering standards across the department. Partner directly with C-Suite to translate business goals into technical roadmaps.

• Complete cloud migration cutting latency 90% and infrastructure costs 50%
• Re-engineered core search logic, 50% increase in user engagement
• Built a payment gateway covering MoMo, ZaloPay, and credit cards
• Built internal marketing automation tools that tripled lead generation efficiency
• Engineered a real-time testing platform handling thousands of concurrent users for large-scale student competitions

January 2016 – January 2017

Technical management for a financial software firm, bridging European stakeholders and a local engineering team in Vietnam.

Led and mentored local developers delivering high-performance, low-latency financial applications in C#/.NET for the banking sector. Worked directly with the CEO on operational reporting and resource allocation. Established development processes including technology selection, time estimation, and quality control. Led technical screening and hiring to scale the team.

Personally architected a backend solution connecting multiple disparate financial systems.

November 2012 – April 2015

Backend development for a fast-paced Swedish tech startup. Built core backend systems for web applications in Python, taking full ownership of feature lifecycles from estimation to deployment. Autonomous environment, high standards, early foundation in scalable architecture and clean code.

June 2025 – August 2025

Implemented DQN, REINFORCE, and PPO from scratch using PyTorch. The agent was constrained to first-person visual input only; full game state was available but deliberately excluded. Switched to StableBaselines3 for parallel training once parallel rollouts became the bottleneck.