AI Agent & Backend Engineer · Selected work

From model output
to working products.

Five independent projects: the problem, my implementation, and the evidence behind it. These are separate from my employment. Source and historical verification records were reviewed on October 7, 2026.

5 Projects · Agent execution · FastAPI + Docker · Source and scope per case

For resume reviewers

What to look for in these cases

Agent execution

Tool admission, bounded reasoning, context, cancellation, and recovery—with the validation scope stated per case.

End-to-end ownership

React interfaces, backend APIs, data models, authentication, and deployment around the AI workflow.

Applied AI

Document questions, manuscript revision, book publishing, and research data. Quant is one application of the work.

How the projects fit together

Agent harness. QuantSigma now uses Elixir/Jido with OTP supervision and Oban durable jobs for new sessions. PostgreSQL retains application history and effect records. Earlier Rust/Rig and Go/Eino Temporal runtimes remain available for historical pinned-session recovery.

AI workflows and integration. Agent Hub connects independently owned services and manages task admission and status. Book Writer uses its own LangGraph revision workflow, structural checks, and file checkpoints. These projects have separate execution models.

Products and public examples. Folio Books handles publishing and reader access. The Book Writer demo uses synthetic replies to demonstrate manuscript checks in the browser; it does not run a model or the full agent runtime.

01 — Agent platform
01
2026 · Independent project

Agent Hub

Document Q&A, research jobs, and review workflows in one console

Console

React

API

FastAPI

Connections

MCP / A2A

I built the React and FastAPI console, authentication, tool integration, and deployment for a platform that connects document questions, CSV backtests, and product-document checks. A shared admission and status layer keeps the UI independent of each service’s execution model. LangGraph handles the reasoning flow; the application checks who can run a task and what tools it can use.

Reviewer quick read

  • Ownership: frontend, APIs, authentication, tool connections, and personal-server deployment.
  • Decision: separate model/tool selection, request admission, and the service that executes a job.
  • User result: follow a task from its accepted ID to status, cited output, or cancellation.
MCP, A2A, and REST connections through the open-source Agentgateway; I implemented the Hub integration.
Matching owner, request key, and input hash reuse an accepted response. Reusing a key with different input returns HTTP 409.
An uncertain external admission blocks automatic resubmission. Cancellation checks worker termination and suppresses late results.
Document/version-scoped retrieval and citation matching; no model call when retrieval returns no evidence.

Evidence and scope

Source and retained checks: September 2026. Worker cancellation was checked in an isolated deployment; retrieval comparisons used a small fixed query set. These do not establish customer-scale operation, general answer accuracy, or crash-safe concurrent resume.

Project overview on LinkedIn ↗
React Python FastAPI LangGraph MCP A2A Docker
02 — Agent runtime
02
2026 · Independent project in development

QuantSigma Agent Harness

Elixir / Jido / Oban, with version-pinned recovery for earlier Rust and Go sessions

New sessions

Jido

Durable jobs

Oban

Tool scope

Read-only

I built and compared Rust/Rig, Go/Eino, and Elixir/Jido adapters, then consolidated new sessions on a native Elixir harness. Jido handles reasoning, OTP supervises processes, and Oban schedules durable work. PostgreSQL retains context, leases, and effect receipts. Earlier Rust/Go runtimes remain available for historical pinned-session recovery.

Reviewer quick read

  • Ownership: reasoning adapters, context and execution contracts, and recovery behavior.
  • Decision: preserve the execution contract while reducing active runtime choices to Jido; retain compatible artifacts for older sessions.
  • Application: read-only investigation of service state, market data, and stored observations, with provenance and unresolved questions.
October 8 architecture: new sessions use Jido/Oban; earlier Rust/Go Temporal implementations serve historical recovery. The Rust terminal is a client.
Exact request matching reuses retained replies; replay itself does not perform model or source HTTP calls.
An unknown external outcome requires explicit recovery with the same request identity. Leases fence late commits; they cannot retract remote work.
Sessions are pinned to engine/runtime versions. The retained archive and bounded model context serve different purposes.

Evidence and scope

Source review: October 8, 2026, agent collection, Jido consolidation and context-continuity implementation. New sessions use the native Elixir harness; earlier Go/Rust/Temporal designs remain historical. Recorded deployment checks were not rerun for this page. External submissions require separate approval and enabled capabilities; no trading returns or exactly-once external effects are claimed.

Earlier Go design: execution boundaries ↗Earlier Rust design: replay and typed IDs ↗
Rust Rig Go Eino Elixir Jido Oban Temporal PostgreSQL
03 — Applied AI workflow
03
May–August 2026 · Development and revision

Book Writer

AI-assisted technical manuscript translation and revision

Applied to

2 books

Search

Topic + style

Review

Author-led

I built a workflow for translating English drafts into Korean technical prose and revising terminology, style, and logical flow. Topic and writing-style examples are retrieved separately. LangGraph stages the revision work, and structural checks protect the manuscript before I review the technical content. I applied it to two of my own technical books.

Reviewer quick read

  • Ownership: translation, retrieval, staged revision, structural checks, and restart records.
  • Decision: retain the source section when code markers disappear or the generated output fails structural checks.
  • Application: manuscript preparation for the Tauri 2 and Python trading-system books.
ChromaDB and ko-sroberta embeddings with source/page metadata and file-hash incremental indexing.
Code blocks are masked; missing markers, lost headings, severe shortening, and editorial meta-text are checked.
File checkpoints and translation progress records allow interrupted work to resume.
Human review checks meaning and technical accuracy after structural validation. Folio handles publishing separately.

Evidence and scope

Development records: May 4–August 21, 2026; manuscript application documented in the September portfolio review. This period is not continuous server uptime. No measured translation-quality uplift or time-saved percentage is claimed.

Try manuscript protection demo ↗Read the Tauri book ↗Read the Python book ↗
Python LangGraph ChromaDB RAG Claude SentenceTransformers
04 — Product engineering
04
2026 · Independent service

Folio Books

A publishing and reading platform for technical books

Author books

3

Data

PostgreSQL

Editing

Revision checks

I built the author studio, reader interface, data model, APIs, authentication, purchase verification, and edit-conflict handling. The product carries a manuscript from authoring to publication and gives readers access to public chapters and entitled content. It also hosts my writing about developer hiring.

Reviewer quick read

  • Ownership: React UI, Python Robyn backend, PostgreSQL model, and access control.
  • Decision: recheck purchase state at content access; a provider outage can temporarily deny an entitled reader.
  • User result: separate author editing, publication, and reader access in one product.
Session and resource-ownership checks guard author operations and content access.
Revision-conditional updates detect concurrent edit conflicts rather than silently overwriting changes.
Dedicated PostgreSQL integration tests covered access restrictions, session invalidation after password reset, and edit conflicts.
Three Korean books connect the product to my own development, validation, and hiring experience.

Evidence and scope

Implementation and PostgreSQL integration-test records: September 28, 2026. Book links reviewed October 7. These demonstrate implemented flows, not paid-customer counts or revenue.

Open Folio Books ↗Developer hiring book ↗
React Python Robyn PostgreSQL TypeScript
05 — Data and execution systems
05
2022–present · Independent project

Stock Trading AI

Market-data pipelines and explicit order-state handling

5-minute bars snapshot

~285M rows

Snapshot date

2026-09-30

Focus

Data integrity

I built data collection, storage, analytical jobs, and order-management backends for a personal market-research system. The current portfolio focuses on preserving source evidence and handling uncertain execution states. QuestDB and a separate PostgreSQL/TimescaleDB path serve different storage workflows; I do not add their row counts together.

Reviewer quick read

  • Ownership: ingestion and storage checks, analytical jobs, order-state handling, and Python/Rust integration.
  • Decision: preserve raw responses and flag suspect rows instead of deleting evidence during cleaning.
  • Recovery: reconcile stored execution observations before repeating an uncertain order-related action.
Raw payloads, hashes, and collection history support comparison before and after UPSERT; clean views exclude flagged rows.
Temporal handles retries, timeouts, and progress for selected jobs. A separate order controller owns fill-state handling.
Rust Axum/Tokio gateway and PyO3/gel-tokio integration connect Python execution logic and a Rust data layer.
ML/RL experiments and model-serving work are research components; their presence alone does not establish investment performance.

Evidence and scope

The September 30, 2026 read-only TimescaleDB query recorded about 285 million rows and 10.36 GiB for fmp_bars_5m, with table timestamps spanning September 2021–September 2026. This is a historical table snapshot, not complete coverage per instrument, current uptime, independently reconciled fills, or a return benchmark. No database or live-trading checks were rerun for this page.

Public financial ML companion repository ↗
Python Rust Temporal PostgreSQL TimescaleDB QuestDB PyTorch

Current engineering notes · October 2026

Inside an agent harness

These October 7 articles document the earlier Go and Rust designs. New sessions now use Jido/Oban; the recovery principles still inform the active harness.

Go: reasoning and execution

How Eino hands external operations to a shared execution layer, and what recovery needs when the outcome is unknown.

Rust: replay and typed IDs

Rig state transitions, exact request matching, and the boundary between internal identifiers and a provider’s protocol.

Reading guide on Medium ↗ · Earlier build notes →

Writing from practice · Korean books

Build, verify, explain.

English title translations are shown below. These links open the Korean editions.

Building Tauri 2 Desktop Apps with AI, from Start to Finish

Original title: AI와 끝까지 완성하는 Tauri 2 데스크톱 앱

AI-assisted desktop development: requirements, implementation, verification, and release.

WikiDocs · Free selected chapters ↗

AI Built the Trading System. Who Checks It?

Original title: AI가 만든 자동매매, 검증은 누가 할까?

Reviewing data, backtest accounting, and the assumptions in an AI-assisted Python trading system.

WikiDocs · Free selected chapters ↗

Hiring Developers: A Developer’s Perspective

Original title: 개발자를 뽑는 개발자

Practical lessons from reviewing applications and conducting technical interviews.

WikiDocs · Free full text ↗

Also available to read on Folio Books ↗.