Elias Matriano · AI builder

Hi, I’m Elias. I build AI you can run, inspect, and ship.

I’m a full-stack AI builder focused on local-first systems: agents, RAG chatbots, automation pipelines, and interactive apps. I care about clear architecture, real demos, and tools that hold up beyond a screenshot.

View my work My resume
  • 5 projects
  • Local models
  • Open architecture
Portrait of Elias Matriano

Expertise

What I bring to the table

Three lanes I ship in: wiring AI into real products, building learning systems you can explain, and designing interfaces people actually use. Each card is a lane I can own end-to-end—from architecture to demo.

  • 01

    AI Integration

    Connecting models to real apps: APIs, RAG pipelines, local and cloud LLMs, and production-ready chat or agent surfaces that hold up past a demo. I care about explicit data flow, observable failures, and interfaces operators can trust—not opaque chains you cannot debug.

    • Local-first RAG (Chroma, embeddings, Ollama / cloud fallbacks)
    • Streaming chat UIs with citations, retries, and tok/s metrics
    • Agent loops: plan → act → observe with inspectable tool calls
    • FastAPI / REST services, SSE streaming, env-based model routing
    • Web search + document grounding for interview-ready demos

  • 02

    Machine Learning

    Training, evaluating, and deploying models with clear data flow: embeddings, retrieval, evaluation loops, and systems you can inspect and improve over time. Focus on practical fine-tunes, small open models, and measurement over vibes.

    • Embeddings, vector search, and chunking strategy for RAG
    • Fine-tuning small LLMs (1B–2B) for routers and tool calling
    • Eval harnesses: grounded vs ungrounded, latency, failure modes
    • Vision / OCR pipelines for document automation workflows
    • Structured outputs (JSON / Pydantic) with validation gates

  • 03

    Graphics Design · UI / UX

    Visual systems and product UI: clean layouts, interaction design, and interfaces that make complex AI tools feel simple, readable, and intentional. Design that supports the demo story, not just decoration around a model call.

    • Dark / themed product shells with clear hierarchy and type
    • Chat, inspector, and gallery patterns for AI product surfaces
    • Responsive layouts, sticky nav, and accessible controls
    • Screenshot-ready polish for portfolio and case-study storytelling
    • Design systems that stay consistent across multi-project sites

Project 01 · Lumen

Local RAG Chatbot

Explicit retrieval and local models, with no LangChain black box.

Portfolio-grade, local-only RAG chat: FastAPI + ChromaDB + bge-small embeddings + Qwen via Ollama, with a plain HTML/CSS/JS frontend. Every retrieval step is explicit and interview-explainable.

Meet Lumen: retrieve relevant chunks from a local Chroma index, ground answers in your docs (or live web results), and generate on your machine. Compare with vs without RAG so the value of retrieval is visible, not assumed.

  • Python
  • FastAPI
  • ChromaDB
  • bge-small
  • Ollama / Qwen
  • HTML / CSS / JS
Live demo Repo
Lumen answering an iPhone price question with live web search and numbered sources

Feature 01 · Live search

Web search with cited sources

Ask about current market data and Lumen can pull live results, structure the answer with clear bullets, and attach numbered sources under the reply so every claim stays checkable, not hallucinated.

  • Live web lookup for time-sensitive facts
  • Numbered source list under each answer
  • Generation speed shown (tok/s) + Retry
Lumen chat greeting with token speed metric and retry control

Feature 02 · Local chat

Streaming replies you can measure

Clean chat UI with role-labeled bubbles. Each assistant turn reports generation speed in tokens per second so local model performance is visible, and a one-click Retry regenerates when the first draft misses.

  • Lumen persona + clear You / Assistant roles
  • Live tok/s metric on every completion
  • Retry without retyping the prompt
Comparison mode showing With RAG versus Without RAG answers side by side

Feature 03 · Comparison mode

With RAG vs without, same query

Flip into comparison mode and run one question against both pipelines. Retrieval-on grounds the answer in your indexed docs (chunk counts included); retrieval-off shows what the base model invents without your knowledge base.

  • Side-by-side With RAG / Without RAG panels
  • Chunk count + model id on each path
  • Makes retrieval impact demo-ready for interviews

Skills

What I work with

Relative levels across the stack I use to ship AI products—local models, backends, frontends, and the glue that makes demos hold up past a screenshot.

AI & systems

  • AI integration · RAG pipelines Expert 95%
  • Local LLMs · Ollama · embeddings Expert 92%
  • Agents · plan / act / observe Advanced 88%
  • Fine-tuning · small models · synthetic data Advanced 82%
  • Document AI · OCR · automation Advanced 80%

Engineering

  • Python · FastAPI Expert 93%
  • TypeScript · React · Vite Advanced 85%
  • HTML · CSS · JavaScript Expert 90%
  • UI / UX · product design for AI tools Advanced 90%
  • SQL · SQLite · API design Advanced 84%
  • Git · tooling · local-first workflows Advanced 86%

Project 02 · AI Dungeon Master

AI Dungeon Master

Structured roleplay with world state, deltas, and streaming turns.

A web-based choose-your-own-adventure where the dungeon master is not a free-form chatbot—it is a pipeline. World gen builds factions, locations, NPCs, and constraints; each turn returns narrative, four choices, and a validated StateDelta applied to a structured store.

Context is assembled from lore, scene, flags, and a running summary. Models are chosen at setup: cloud Anthropic Claude or local Ollama. The UI streams progress so you watch the realm write itself in real time.

  • React 19
  • TypeScript
  • Vite
  • FastAPI
  • Pydantic
  • Ollama / Claude
  • SSE
Case study Repo
Lore presets panel with Emberport, Neon Veil, and Ashen Marches worlds

Feature 01 · Lore presets

Full worlds, loaded instantly

Skip cold-start world-gen when you want a sharp first scene. Curated lore presets ship full settings and opening hooks—dark fantasy harbors, cyberpunk megacities, grim frontiers—ready to play.

  • Instant load: full world + opening scene, no model world-gen wait
  • Genre tags: dark fantasy, cyberpunk, grimdark, and more
  • Archetype seeds (e.g. disgraced knight) baked into each preset
World setup form with genre, tone, setting, and protagonist archetype

Feature 02 · World setup

Configure genre, tone, and hero

Custom adventures start from a clear setup sheet: genre, tone, freeform setting, and protagonist archetype. The active model is visible up front so local vs cloud choice is never a mystery.

  • Structured fields instead of a blank chat box
  • Model shown in-line (e.g. local qwen via Ollama)
  • One-click Begin adventure into the turn pipeline
Narrative prose with four numbered player choices

Feature 03 · Turn stream

Narrative plus four grounded choices

Each turn streams prose, then locks in four numbered options. Behind the scenes the model also emits a state delta so factions, locations, and flags stay consistent across a long campaign.

  • Streaming narrative with roleplay-ready detail
  • Exactly four choices per turn for clear agency
  • Validated StateDelta applied to structured world state
Latency inspector showing world gen, narrative stream, and choices timing

Feature 04 · Latency inspector

See where the seconds go

Local models make timing honest. The latency inspector breaks down world generation, narrative stream length, and the choices + delta call so you can tune templates and schemas instead of guessing.

  • Per-phase timings (world gen, narrative, choices + delta)
  • Char counts and status for the last turn
  • Built for Ollama / local JSON-schema turn pipelines

Process

How I build

A repeatable path from fuzzy idea to something you can run, inspect, and demo—not a black-box prototype that dies after the screenshot.

  1. 01

    Frame the problem

    Lock the user job, constraints, and what “done” looks like before picking a model. Prefer a sharp scope over a vague “add AI.”

  2. 02

    Design the architecture

    Sketch data flow, state, APIs, and failure modes. Make retrieval, tools, and human gates explicit—not buried inside a framework.

  3. 03

    Use AI agents where they fit

    Deploy plan → act → observe loops, tool callers, and routers when the task is multi-step—not for every one-shot prompt. Agents stay inspectable: tool calls, replans, and budgets visible in the UI.

  4. 04

    Ship a local demo first

    Get a runnable path on the machine early (Ollama, FastAPI, plain UI). Latency, tok/s, and bad answers show up before polish hides them.

  5. 05

    Add human gates

    Anything that mutates real data or commits structure gets Confirm / Skip, review, or stratified audit. Models propose; people decide.

  6. 06

    Polish and document

    Product UI, clear copy, stack tags, and a story you can explain in an interview. If it only works in a notebook, it is not shipped.

Project 03 · AI Finance Tracker

AI Finance Tracker

Personal finance product UI with ledger truth and tool-using chat.

A full client app for day-to-day money tracking—not a chart demo. Cash vs online balances, monthly net, spending breakdowns, and a transaction ledger you can search, sort, and toggle live.

Meet the AI · tools-only lane: a local model proposes ledger actions (e.g. add income) as explicit tool calls you Confirm or Skip—so the assistant never silently rewrites your books.

  • TypeScript
  • Vite
  • React
  • Local LLM tools
  • Ledger UI
Case study Repo
Finance dashboard with cash, online, and total balances plus charts

Feature 01 · Dashboard

Balances and trends at a glance

Hero metrics for cash, online, and total balance sit above income-vs-expense bars, a spending breakdown, and a multi-series balance trend—so you see health before you scroll the ledger.

  • Cash / online / total balance cards
  • Monthly income vs expense + category breakdown
  • Balance trend across cash, online, and total
Transaction ledger with income and expense rows, search, and toggles

Feature 02 · Ledger

Searchable day-to-day transactions

The ledger groups by day with running context: salary, rent, utilities, opening balances—each tagged ONLINE or CASH, FINAL status, and quick enable/edit/remove controls.

  • Search + date sort across the full item set
  • Income (green) / expense (red) visual language
  • Channel tags and live toggles per row
AI tools-only chat proposing an income entry with Confirm and Skip

Feature 03 · Tools chat

Propose, then you confirm

Natural language like “add 50 php on Jul 27” becomes a pending tool action with a clear payload. Nothing hits the ledger until you confirm— tools-only mode keeps the model on structured actions, not free-form edits.

  • Local model tool calls (e.g. qwen) with forced-search flags
  • Pending action cards with Confirm / Skip
  • Human gate on every money-moving mutation

Quality bar

What I optimize for

When tradeoffs appear, these are the axes I protect first—especially between product tools (Finance) and ops pipelines (Automation).

  • 01

    Explainability

    Retrieval, tool calls, and decisions should be visible. If you cannot show the path, you cannot debug or trust it in an interview—or production.

  • 02

    Human-in-the-loop

    Confirm, skip, review, and audit gates on anything that spends money, writes a ledger, or commits extracted fields. Autonomy without a kill switch is a liability.

  • 03

    Source-of-truth UI

    Put the PDF, the doc, or the state next to the model output. Ground truth stays open so operators never have to “believe the bubble.”

  • 04

    Local deployability

    Prefer stacks that run on your machine when possible—Ollama, FastAPI, portable frontends—so demos and privacy do not depend on a single API key.

  • 05

    Demo readiness

    Screenshot-worthy UI, clear failure modes, and a narrative you can walk through live. A model without a surface people can use is half a product.

  • 06

    Boring ROI when it wins

    Intake → extract → review → export often beats chat theater. Optimize for hours saved and errors caught, not for looking futuristic.

Project 04 · AI Automation

Clearpost · Invoice automation

Intake, review, and export for messy real-world PDFs.

Document automation built for ops reality: drop invoices into a file log, extract structured fields with confidence scores, and open a side-by-side review where the PDF and parsed records stay aligned.

Modes cover technical summaries, readable summaries, structured Records, and full review—so different roles can consume the same pipeline without re-running inference.

  • Python
  • PDF / OCR
  • Document AI
  • Review UI
  • Export
Case study Repo
Clearpost file log listing committed PDF invoices with confidence scores

Feature 01 · File log

Intake queue with confidence

Every uploaded PDF lands in a committed file log: filename, type, and a confidence score so operators see which docs are ready and which need a closer look before export.

  • Invoice intake → review → export pipeline framing
  • Per-file confidence (e.g. 0.87–0.95)
  • Clear status chips for committed PDFs
Side-by-side invoice PDF viewer and extracted vendor, line items, and validation

Feature 02 · Side-by-side review

PDF truth next to extracted fields

Review mode puts the source invoice beside structured extraction: vendor, invoice number, date, totals, and line items—with validation issues surfaced when something does not add up.

  • Embedded PDF viewer with page controls
  • Structured fields + line-item breakdown
  • Validation status and Edit in review path
Mode tabs for technical summary, readable summary, records, and review all

Feature 03 · Output modes

One pipeline, four reading modes

Switch between technical summary, readable summary, structured records, and full review without re-uploading. Choose file when you need a new document; stay in-mode when you are auditing a batch.

  • Tabbed modes for different stakeholders
  • Records mode for structured downstream export
  • Lightweight choose-file entry for new intake

Education

Where I’ve studied

High school · 2019 – 2024

Marcial B. Villanueva National High School

ICT Strand

Senior high school with a strong Information and Communications Technology focus—foundations in computing, digital systems, and practical project work that led into full-stack and AI building.

  • ICT strand coursework: computing fundamentals and digital literacy
  • Hands-on projects that built problem-solving and documentation habits
  • Early exposure to software, media, and systems thinking
  • 2019 – 2024 · foundation for Computer Science at STI Lucena

Where I’m currently studying

University · 2024 – 2028

STI College Lucena

Bachelor of Science in Computer Science

Actively studying Computer Science while shipping portfolio AI systems: local agents, RAG chatbots, automation pipelines, and product UIs. Coursework and self-directed builds reinforce each other.

  • Core CS: algorithms, software design, databases, and systems
  • Parallel track: local LLMs, RAG, agents, and full-stack demos
  • Goal: ship explainable AI products, not only classroom exercises
  • Expected path · 2024 – 2028

Project 05 · Research Agent

Research Agent

Plan → act → observe with a live inspector and cited answers.

Multi-step research agent for multi-part questions: plan the work, call tools (search, fetch), replan when needed, and synthesize a grounded answer with citations—no black-box chain.

The UI splits Query / Answer from a live Inspector so you can watch plan steps, tool-call budget, replan events, reasoning trace, and scratchpad as the agent runs.

  • Python
  • FastAPI
  • Ollama / Qwen
  • Tavily
  • trafilatura
  • httpx
Case study Repo
Research agent query panel with multi-part question, max tool calls, and answer area

Feature 01 · Query surface

Multi-part questions, capped tools

Start with a research question and an explicit max tool-call budget. The answer pane is reserved for the final synthesized reply with citations—clean separation between ask, run, and result.

  • Multi-part research prompt field
  • Configurable max tool calls (e.g. 12)
  • Dedicated answer region for cited synthesis
Live inspector showing plan, tool calls, replan events, reasoning trace, and scratchpad

Feature 02 · Live inspector

Plan, tools, replans—fully visible

The inspector streams the agent’s working memory: current plan, tool-call counter, replan events, reasoning trace, and scratchpad. Built for interviews and debugging, not opaque “thinking…”.

  • Live plan steps and replan events
  • Tool call budget (e.g. 0 / 12) always on screen
  • Reasoning trace + scratchpad for auditability

Open to work

Available for hire

I’m looking for roles and contracts where I can ship AI systems that are local-friendly, explainable, and product-ready—not slideware. Happy to join full-time, part-time, fixed-term, or freelance.

  • Full-time
  • Part-time
  • Fixed term
  • Freelance contracts

Strongest fit: full-stack AI integration, RAG / agent demos, small-model fine-tunes, and polished UI for technical products. Comfortable owning architecture, implementation, and the story you show stakeholders.

Offered skills

Relative strengths I bring to a team or client engagement:

  • AI Integration & RAG systems 95%
  • Python · FastAPI · local LLMs 92%
  • Agent design (plan / act / observe) 88%
  • UI / UX for AI products 90%
  • TypeScript · React · product frontends 85%
  • Fine-tuning & small-model tooling 82%
  • Automation · OCR · document pipelines 80%

Live demo

AI Chatbot (Local RAG)

Portfolio-grade, local-only RAG: FastAPI + ChromaDB + embeddings + Ollama. No LangChain black box: every retrieval step is explicit.

Demo UI ready. Wire to your chatbot API.

Hi, I’m the local RAG demo shell. Connect me to your Chatbot backend to answer from your documents.

Placeholder only. Point js/main.js at your Chatbot API (e.g. http://127.0.0.1:8000) when ready.

Contact

Let’s talk

Open to roles, collabs, and interesting AI product problems.

Research

Writing & design papers

Literature-grounded work for synthetic dataset engineers—architecture and viability, not leaderboard theater.

Design paper · 2026

A Staged Synthetic Instruction-Data Factory: Design Rationale and Viability for Dataset Engineers

Conversational SFT data for small open-weight models—when is a multi-stage factory viable?

A practitioner-facing design synthesis of a two-phase synthetic instruction-data factory: constrained design space (taxonomy, variables, compatibility, golden seeds) followed by airgapped generation, hybrid automated QC, stratified human audit, and regeneration with lineage. Maps each stage to prior work on Self-Instruct, LLM-as-a-judge, and model collapse. Concludes conditional viability under explicit human gates and diversity controls—and includes a falsifiable validation protocol for engineers.

  • Domain: synthetic conversational instruction data (SFT / ChatML)
  • Scope: data factory only (P1–P8)—no training or benchmark claims
  • Audience: synthetic dataset engineers
  • Type: design / architecture paper with literature-backed viability analysis
Read PDF
Preview of the Synthetic Instruction-Data Factory research paper

In progress

Ongoing projects

Active fine-tunes on small open models—built for local inference, clear roles, and composable multi-agent stacks.

Fine-tune · 1B router

Llama 3.2 1B · Mixture-of-Agents router

Routing specialist that picks which specialist agent should answer.

Fine-tuning Meta Llama 3.2 1B Instruct as a lightweight mixture-of-agents router: classify the user intent, choose the right worker (research, code, RAG, ops, creative), and emit a structured handoff. Small enough to run locally; sharp enough to keep a multi-agent graph from thrashing.

  • Base model: Llama 3.2 1B Instruct (~1B params)
  • Role: intent classification + agent selection for MoA stacks
  • Outputs: route id, confidence, short rationale, optional rewrite
  • Training focus: multi-domain prompts, ambiguous intents, refusals
  • Deploy target: Ollama / local runtime as first hop before specialists

Fine-tune · 2B tool caller

Gemma 2 2B · 15-tool function caller

Tool-using specialist that plans and invokes a fixed tool belt.

Fine-tuning Google Gemma 2 2B IT as a dedicated tool caller that can select and invoke up to 15 tools—search, fetch, file ops, calculators, structured stores, and custom APIs—with valid argument schemas and multi-step call chains. Pairs with the 1B router: router chooses the lane; this model executes tool-heavy work.

  • Base model: Gemma 2 2B IT (~2B params)
  • Role: multi-step tool use with schema-valid JSON / function calls
  • Tool belt: up to 15 registered tools (search, fetch, compute, I/O…)
  • Training focus: argument accuracy, tool order, recovery from errors
  • Deploy target: local agent worker behind the MoA router