AI Engineering Notes by Sevada Yenokyan

SUPPORT-LINK-8 connects each support answer to current permitted documentation with source IDs, revisions, locators, link checks and a safe escalation route.

$ support-rag --contract SUPPORT-LINK-8
> filter: product / locale / state / audience
> retrieve: current passages / revision / locator
> route: answer / no-answer / escalation / account-action

KBASE-9 treats a corporate knowledge base as a controlled source-to-answer contract: owned sources, staged versions, retrieval filters, citations and human review.

$ initialize knowledge-base --contract KBASE-9
> register: source / owner / revision / scope
> verify: access / currentness / no-answer
> route: promote / review / quarantine / remove

INDEX-UPDATE-8 treats source updates, version promotion and data removal as one observable contract: idempotent jobs, staged candidates, verification probes and reconciliation.

$ update rag-index --contract INDEX-UPDATE-8
> stage: extract / normalize / chunk / write
> verify: hash / count / access / retrieval
> route: promote / retry / quarantine / remove

ACL-RAG-8 constrains retrieval with server-trusted identity, tenant, entitlement and lifecycle policy before ranking or model context, with tested revocation and a fail-closed route.

$ enforce rag-access --contract ACL-RAG-8
> resolve: session / subject / tenant / entitlements
> retrieve: eligible passages only
> route: answer / deny / clarification / review

ML-RAG-9 treats language as an evidence contract: locale policy, language-aware retrieval, source lineage, per-language evaluation and a safe fallback route.

$ retrieve multilingual --contract ML-RAG-9
> inspect: locale / language confidence
> verify: source / coverage / fallback
> route: answer / clarify / review / no-answer

TRACE-8 keeps source, version and locator beside every material claim through retrieval, citation coverage, link checks and an honest review/no-answer route.

$ trace rag --contract TRACE-8
> retrieve: source / version / locator
> verify: links / lifecycle / access
> route: answer / review / no-answer

RERANK-7 separates broad candidate retrieval from controlled evidence selection through trusted scope, pinned scoring, diversity, citations and an honest no-answer route.

$ rerank rag --contract RERANK-7
> retrieve: broad eligible candidate set
> select: diversity / citations / evidence
> route: answer / review / fail-closed

HYBRID-8 joins lexical and semantic signals only after trusted scope, source lifecycle, fusion, evidence checks and an honest no-answer route.

$ retrieve hybrid --contract HYBRID-8
> scope: tenant / role / lifecycle / locale
> search: bm25 / embeddings / trusted corpus
> route: citation / review / fail-closed

VECTOR-6 compares workload, trusted filters, lifecycle, testability, operations and retrieval fit instead of naming a universal winner.

$ decide vector-store --contract VECTOR-6
> compare: volume / eligibility / change
> test: retrieval / denied / update / no-answer
> route: pilot / rollout / reject

META-7 connects trusted identity, metadata, deterministic filters, provenance and a no-answer route before a model receives context.

$ scope rag --contract META-7
> classify: tenant / audience / language / type
> filter: permissions / lifecycle / product
> route: evidence / review / deny

EMBED-5 traces a source passage and question through vector similarity, filters, evidence review and an honest no-answer route.

$ inspect embeddings --contract EMBED-5
> encode: source / query / model-version
> retrieve: similarity / filters / provenance
> verify: evidence / no-answer / correction

CHUNK-7 connects document structure, semantic boundaries, explicit continuity, source lineage, evaluation and controlled indexing.

$ chunk rag --contract CHUNK-7
> parse: structure / table / locator
> bound: semantic unit / overlap / lineage
> verify: normal / denied / changed / no-answer

SRC-6 verifies source identity, authority, lifecycle, access, structure and correction ownership before documents become retrieval evidence.

$ inspect rag-sources --contract SRC-6
> classify: authority / lifecycle / access
> test: retrieval / denied / no-answer
> route: approve / quarantine / reviewer

RAG-NO-7 separates retrieval-shaped work from rules, templates, direct integrations, search, data readiness and human review before unnecessary complexity.

$ decide rag --contract RAG-NO-7
> inspect: authority / freshness / access
> compare: rule / template / system / search
> route: readiness / bounded-rag / simpler-path

RFT-5 compares freshness, evidence, access boundaries, dataset operations and evaluation to select retrieval, fine-tuning or a simpler baseline.

$ decide knowledge --contract RFT-5
> inspect: freshness / evidence / access
> compare: retrieval / behaviour / correction-loop
> route: RAG / fine-tune-test / hybrid / baseline

RAG-4 connects a question, permission-filtered retrieval, visible evidence, a bounded answer and human review without turning documents into a black box.

$ trace rag --contract RAG-4
> retrieve: permissions / sources / candidates
> evidence: passages / links / versions
> route: answer / review / no-answer

PILOT-30 connects a process audit, workflow contract, integration checks, acceptance criteria and an evidence-based rollout decision.

$ pilot-30 --contract PILOT-30
> audit: boundary / owner / baseline / exclusions
> validate: normal / exception / recovery / read-back
> decide: stop / revise / staged-rollout

ROI-RANGE-7 connects a time baseline, TCO, risk reserve, scenario ranges, review and a controlled 30-day pilot decision.

$ estimate roi --contract ROI-RANGE-7
> measure: volume / minutes / quality / handoffs
> model: low / expected / high / TCO
> decide: reviewer / pilot / read-back / revise

FIN-GUARD-6 connects source evidence, a bounded AI proposal, deterministic checks, named review, permitted action and verified read-back.

$ finance-pilot --contract FIN-GUARD-6
> propose: bounded classification / exception
> validate: amount / identity / policy / duplicate
> commit: reviewer / read-back / recovery

REPORT-8 connects approved source receipts, deterministic metrics, validation gates, bounded narrative, owner review and verified report delivery.

$ build report --contract REPORT-8
> collect: sources / receipts / freshness
> validate: metrics / reconcile / exceptions
> publish: reviewer / read-back / recovery

ONBOARD-7 connects a verified onboarding event, permission-scoped knowledge, role rules, human approval and verified destination read-back.

$ onboard employee --contract ONBOARD-7
> retrieve: allowed knowledge / citations / gaps
> validate: role rules / entitlement / policy
> commit: reviewer / read-back / recovery

PROCURE-7 connects source requests, bounded classification evidence, policy routing, human approval and verified destination read-back.

$ process procurement-request --contract PROCURE-7
> classify: category / evidence / uncertainty
> validate: taxonomy / policy / reference-data
> commit: reviewer / read-back / recovery

DOCS-7 connects source files, typed extraction evidence, validation gates, human authority and verified accounting-system read-back.

$ process document --contract DOCS-7
> extract: typed fields / evidence / uncertainty
> validate: match / arithmetic / policy
> commit: reviewer / read-back / recovery

CALL-6 connects a call source, transcript evidence, bounded summary, policy gate, human review and verified CRM read-back.

$ summarize call --contract CALL-6
> capture: call / tenant / source receipt
> validate: schema / action / policy
> commit: reviewer / read-back / recovery

ESCALATE-7 connects source evidence, a bounded risk proposal, policy gates, human final authority and verified CRM case read-back.

$ escalate complaint --contract ESCALATE-7
> extract: indicators / evidence / uncertainty
> gate: policy / reviewer / deadline
> commit: decision / read-back / recovery

CHANNEL-8 connects channel receipts, tenant-scoped conversation state, bounded AI proposals, policy gates, human ownership and verified destination read-back.

$ support layer --contract CHANNEL-8
> receive: channel / external-id / timestamp
> resolve: tenant / contact / conversation
> commit: policy / owner / read-back

ROUTE-7 connects a support event, bounded AI proposal, policy gate, named owner and verified queue assignment.

$ route support --contract ROUTE-7
> accept: event / channel / timestamp
> validate: schema / queue / policy
> route: review / escalation / read-back

EMAIL-6 connects a permitted CRM signal, a bounded email draft, policy checks, human review and provider/CRM receipt without autonomous outreach.

$ draft sales-email --contract EMAIL-6
> capture: task / permission / owner
> validate: context / claims / frequency
> route: review / approval / receipt

ENRICH-6 connects source evidence, field contracts, identity checks, human review and a verified CRM read-back.

$ enrich crm --contract ENRICH-6
> preserve: record / source / consent
> validate: policy / match / authority
> verify: CRM read-back / receipt

LEAD-7 separates a model recommendation from policy, CRM de-duplication, owner review and a verified outcome.

$ qualify lead --model LEAD-7
> locate: event / source / consent
> decide: rules / duplicate / owner
> verify: CRM read-back / correction

The CODE-6 matrix weighs contract complexity, recovery, delivery, execution profile, ownership and exit before extracting code from a workflow.

$ decide boundary --matrix CODE-6
> inspect: contract / recovery / delivery
> measure: latency / concurrency / repair
> extract: smallest useful capability

The SCOPE-7 operating model connects structured logs, actionable alerts, queue signals, reconciliation and controlled recovery.

$ monitor n8n --model SCOPE-7
> correlate: event / workflow / version
> observe: outcome / queue / duration
> recover: review / reconcile / close

The CRED-8 architecture separates key custody, credential storage, target authorization, runtime redaction, rotation, recovery and audit evidence.

$ secure n8n --contract CRED-8
> protect: key / store / runtime
> authorize: identity / scope / denied-path
> operate: rotate / restore / audit

The APPROVE-7 workflow separates AI proposals from authority with policy routing, expiring review tasks, revalidation and idempotent execution.

$ gate n8n --contract APPROVE-7
> propose: action / evidence
> decide: authority / reason / expiry
> execute: revalidate / receipt

The RIDE-5 protocol classifies failures, bounds retries, protects side effects and turns dead-letter events into controlled recovery.

$ recover n8n --protocol RIDE-5
> classify: transient / permanent / ambiguous
> protect: key / ledger / receipt
> exit: complete / dead-letter / replay

The SELECT-6 weighted matrix compares speed, engineering control, lifecycle, TCO, compliance and team fit across three scenarios.

$ compare automation --matrix SELECT-6
> weight: requirements / risk
> score: evidence / TCO / fit
> verify: two bounded pilots

The FLOW-8 reference architecture for explicit item semantics, normalized contracts, idempotent writes, recovery, retention and measured scaling.

$ inspect n8n --contract FLOW-8
> frame: event / item-model
> operate: write / recover / retain
> scale: queue / workers / limits

The TRACE-9 reference architecture for durable events, bounded inference, validation, human approval, idempotent execution and authoritative reconciliation.

$ trace automation --contract TRACE-9
> receive: event / identity / version
> gate: policy / approval / freshness
> verify: action / receipt / reconciliation

A DATA-5 audit matrix for access, rights, quality, meaning and freshness, with maturity gates and risk-based repair priorities.

$ audit data --matrix DATA-5
> inspect: access / quality / lineage
> classify: stop / repair / control
> route: discovery / pilot / ready

An evidence-based PILOT-8 worksheet for comparing value, readiness, reversibility, failure containment and ownership before implementation.

$ score candidates --matrix PILOT-8
> value: outcome / frequency / evaluation
> risk: data / reversibility / containment
> route: pilot / redesign / reject

A HIL-GATE production architecture with REVIEW-7 triggers, evidence packets, attributable decisions, safe timeouts and revalidated execution.

$ inspect workflow --human-boundary
> route: auto / review / stop
> decide: evidence / authority / reason
> execute: revalidate / audit / rollback

A BOUND-6 weighted decision matrix comparing RPA, AI and hybrid architectures across fit, control, TCO and three typical scenarios.

$ compare automation --rpa --ai
> map: stability / input / judgment
> weigh: control / TCO
> route: rpa / ai / hybrid / redesign

A decision guide with the STOP-AI tree, BOUNDARY matrix, human review contract and controlled alternatives to unsafe autonomy.

$ assess automation_boundary --process candidate
> inspect: stakes / evidence / permissions
> classify: automate / assist / wait
> require: appeal / rollback / stop-owner

A process-first guide with the MAP-FIRST decision tree, PROCESS priority matrix, solution comparison, risk controls and pilot sequence.

$ map process --before-model
> observe: trigger / decision / outcome
> compare: rules / RPA / AI / agent
> decide: stop / narrow / harden / expand

REMOTE-6 selection criteria, delivery gates, time-zone agreements, production control and handoff for distributed AI teams.

$ assess remote_delivery --from-armenia
> select: evidence / ownership
> control: reviews / release / rollback
> transfer: assets / runbooks / operator

A language-aware production architecture for detection, normalization, retrieval, structured output, failure handling and per-language evaluation.

$ inspect multilingual_ai --languages hy,ru,en
> preserve: original / language state
> control: schema / approval / fallback
> observe: quality by language

A practical workshop route from process evidence and multilingual data to integration contracts, acceptance criteria and a controlled pilot.

$ run ai_workshop --yerevan
> frame: process / owner / baseline
> verify: evaluation / rollback
> output: controlled pilot gate

A local comparison and original ARCHITECT method for deciding whether part-time AI architecture leadership fits a startup or operating company.

$ assess fractional_architect --armenia
> fit: senior decisions / periodic load
> govern: cadence / gates / rights
> exit: ownership / capability transfer

A local evidence-based analysis of persistent browser sessions, parallel QA, retries, Chromium processes and memory pressure.

$ inspect codex_browser --resource-lifecycle
> tabs: routes × viewports × agents
> pressure: memory / swap / retries
> controls: reuse / cleanup / hard-limit

A decision tree for selecting a first AI use case through process, data, multilingual evaluation, risk and a controlled pilot.

$ assess armenian_smb --first-ai-pilot
> frame: process / owner / baseline
> score: pain / data / risk
> decide: stop / narrow / harden / expand

A practical route from a testable startup hypothesis through data, evaluation and integration gates to a controlled AI MVP.

$ route startup_ai --hypothesis-to-mvp
> discover: workflow / data / baseline
> test: spike / evaluation / fallback
> ship: controlled MVP or stop

When Luna Max can catch Terra Medium, why Sol Medium may beat Terra X-High, and how to route GPT-5.6 by cost per accepted result.

$ evaluate gpt-5.6 --tier luna,terra,sol
> compare: quality / tokens / latency / retries
> tune: medium / high / xhigh / max
> optimize: cost per accepted result

A process map, seven prioritised AI use cases, data and integration requirements, risks, pilot ROI and a controlled rollout plan.

$ map armenian_business --automation-pilot
> route: capture / understand / approve / act
> use cases: triage / documents / crm / alerts
> output: prototype, controlled pilot or stop

A weighted decision matrix comparing local and international AI delivery by context, specialist depth, speed, TCO, risk, control and support.

$ compare ai_contractor --local --international
> weight: context / depth / tco / risk
> scenarios: local ops / research / global platform
> output: local, international, hybrid or discovery

A practical portfolio audit matrix for checking AI specialist evidence: outcomes, data, architecture, evaluation, deployment and ownership.

$ audit ai_specialist_portfolio --evidence
> inspect: outcomes / data / architecture
> score: missing / described / demonstrated / operated
> output: clarify, audit, prototype or contract

A practical audit matrix for checking an AI project estimate: scope, data, integrations, evaluation, approval gates, rollout and ownership.

$ audit ai_project_timeline --estimate
> inspect: scope / data / integrations
> score: unknown / draft / reviewable / ready
> output: discovery, prototype, pilot or rollout

A source-verified guide to GPT-5.6 Sol, Terra and Luna, reasoning modes, ChatGPT Work, API tool use, pricing and GPT-Live.

$ inspect openai_release --model gpt-5.6
> family: sol / terra / luna
> effort: default / max / ultra
> surfaces: chat / work / codex / api / live

A practical AI project brief template for companies: workflow, data, integrations, users, approval gates, risks, scoring and next step.

$ brief ai_project --template company
> map: workflow / data / integrations
> score: unknown / draft / reviewable / ready
> output: discovery, audit, prototype or pilot

A practical red-flag checklist for checking an AI contractor before contract: data, integrations, evaluation, human approval and ownership.

$ audit ai_contractor --red-flags
> inspect: data / integrations / ownership
> score: critical / weak / reviewable / strong
> output: reject, audit first or controlled pilot

A practical checklist for evaluating an AI developer before contract: workflow, data, integrations, risk, human review and ownership.

$ interview ai_developer --before-contract
> questions: 25
> score: outcome / data / ownership
> output: audit, prototype or production scope

A practical procurement matrix for choosing between a freelancer, AI studio, agency or internal team for AI projects in Armenia.

$ compare ai_delivery_format --market armenia
> options: freelancer / ai_studio / agency
> inspect: scope / risk / ownership
> output: route by TCO and support

A practical comparison for choosing between vibe-coded prototypes, AI-assisted MVP work and production engineering in Armenia.

$ evaluate vibe_coder --market armenia
> compare: prototype / mvp / engineering
> inspect: data / integrations / tests
> output: route by risk and TCO

A practical selection framework for AI agent projects in Armenia: workflow fit, tool permissions, RAG context, approval boundaries, risks and next steps.

$ evaluate ai_agent_developer --market armenia
> inspect: workflow / tools / approvals
> route: audit / pilot / production agent
> output: criteria-based selection

A practical selection framework for n8n workflow automation in Armenia: process mapping, credentials, errors, approvals, monitoring and handoff.

$ evaluate n8n_specialist --market armenia
> inspect: workflow / credentials / errors
> route: audit / pilot / production automation
> output: criteria-based selection

A practical selection framework for LLM development in Armenia: prompt contracts, context policy, tool boundaries, evaluation, deployment and ownership.

$ evaluate llm_developer --market armenia
> inspect: scope / prompts / context / tools
> route: audit / prototype / production LLM
> output: criteria-based selection

A practical selection framework for RAG development in Armenia: source audit, retrieval design, citations, evaluation, permissions and update workflow.

$ evaluate rag_developer --market armenia
> inspect: sources / permissions / retrieval
> route: audit / prototype / production RAG
> output: criteria-based selection

A practical estimate model for AI automation in Yerevan: workflow, data readiness, integrations, human controls, evaluation, deployment and maintenance.

$ estimate ai_automation --city yerevan
> inspect: workflow / data / integrations / approvals
> route: audit / pilot / production automation
> output: assumption-based range

A practical cost model for AI development in Armenia: discovery, data preparation, integrations, evaluation, deployment, maintenance and hidden post-demo expenses.

$ estimate ai_project_cost --market armenia --year 2026
> inspect: scope / data / integrations / evaluation
> route: audit / pilot / production / maintenance
> output: range before commitment

A practical guide to using an AI audit before development: workflow value, data readiness, integration risk, evaluation, human control and first pilot scope.

$ audit ai_workflow --market armenia
> inspect: workflow / data / integrations / evaluation
> route: no-build / cleanup / prototype / production pilot
> output: decision before development

A practical comparison of AI delivery models in Armenia: independent specialist, freelancer, studio, agency and in-house hire by workflow, TCO, proof and ownership.

$ compare ai_delivery_models --market armenia
> options: specialist / freelancer / studio / agency / in-house
> score: workflow / data / integrations / evaluation
> route: audit, pilot or long-term capability

A profile-oriented proof map for Sevada Yenokyan and aicoding.am: stack, projects, working standards, artifacts, boundaries and next steps.

$ inspect person_entity --name sevada_yenokyan
> proof: case studies / articles / runbooks
> stack: LLM / RAG / automation / product
> route: profile to project brief

A criteria-based comparison for AI specialists in Armenia: delivery models, weighted matrix, TCO, proof quality, risks, scenarios and next steps.

$ compare ai_specialists --market armenia
> avoid: advertising rankings
> score: workflow / data / evaluation
> route: audit, pilot or long-term capability

A practical guide to evaluating an AI developer in Yerevan: local context, remote production delivery, scoring criteria, red flags and next steps.

$ evaluate ai_developer --city yerevan
> check: workflow / data / integrations
> delivery: repo / review / deploy
> route: audit or narrow pilot

A practical business task map for AI specialist work in Armenia: process mapping, data review, RAG, automation, integrations, human review and rollout ownership.

$ map ai_specialist --market armenia
> choose: automation / rag / agent / tool
> control: human review and logs
> rollout: narrow workflow first

A practical guide for evaluating an AI developer in Armenia: workflow fit, data access, integrations, evaluation, ownership, red flags and a production-safe next step.

$ evaluate ai_developer --market armenia
> check: process / data / integrations
> proof: case studies and evaluation method
> risk: demo-only delivery rejected

A browser-based AR manicure try-on MVP for beauty salons: live camera UX, MediaPipe hand tracking, Canvas2D nail masks, PNG nail assets and privacy-first frontend architecture.

$ npm run dev -- --host 127.0.0.1
> camera: active
> tracking: MediaPipe Hand Landmarker
> canvas: 1280x720

A practical explanation of transformer architecture, self-attention, black box AI, AGI limits, and how AI systems gain empirical experience through memory, RAG, tools, agents and feedback.

$ init transformer_context
> attention_map: active
> black_box_risk: explainability_required
> empirical_loop: action -> feedback -> memory

A routed skill family for AI web design, motion design and vibe coding: design direction, frontend quality gates, motion runtime policy, browser QA and multilingual routing.

$ codex skills validate web-design-motion-family
> route intent to focused skills
> choose CSS, Motion, GSAP, Lottie or Rive only when justified
> verify desktop, mobile, console and reduced motion

A conservative project memory router for Codex: ARCHITECTURE.md keeps the durable project map, runbooks keep repeatable procedures, project skills keep reusable AI workflows, and AGENTS.md stays compact.

$ architecture-update
> scan durable project changes
> route facts to architecture, runbooks, or project skills
> keep AGENTS.md compact

A compact memory layer for AI sessions: AGENTS.md keeps permanent rules, summaries handle handoff, plans own large tasks, and diary files preserve durable context without chat noise.

$ read diary/current.md diary/decisions.md
> load compact project state
> preserve durable decisions
> skip transcripts and cosmetic noise

Controlled self-learning for Codex: update skills extract reusable lessons from completed work, reject local project context, and update global skill families only when the lesson is portable.

$ n8n-skill-update --after-session
> scan completed workflow work
> extract reusable failure modes
> patch one skill or report no change

Production-grade Django operating platform for flower retail: CRM, orders, bouquet recipes, inventory, delivery, POS, storefront, multichannel messaging, analytics, integrations and external APIs in one live system.

$ docker compose -f docker/docker-compose.yml ps
> web / db / redis / celery / telegram-bot / nginx: running
$ python manage.py check
> System check identified no issues

Browser-first B2B inbox for multi-channel operator workflows. Django keeps the canonical workspace data while the React client handles the dialog queue, contacts, media and operator runtime.

$ open workspace
> sync server snapshot
> resolve threads / contacts / media
> process dialogs in browser runtime

The Update All architecture separates reusable lessons from local implementation details and routes them to the right family updater skills. The system's default mode is to change nothing until a lesson proves reusable value.

$ update-all --analyze-session
> candidates: reusable_lessons / project_noise
> route: most_specific_family_updater
> default: no_changes