2026 AI Application Engineer Job-Market Tech Stack: A Deep JD Study of Tokyo, Mainland China, and the US

For engineers seeking AI Application Engineer, AI Agent Engineer, RAG Engineer, Applied AI Engineer, or LLM Application Engineer roles in Tokyo, mainland China, or the Japanese offices of US companies.

Summary

By 2026, AI application roles have plainly moved beyond the stage where knowing how to call an LLM API and write prompts is enough to enter the field.

Recent public job descriptions repeatedly ask for one complete engineering capability:

Python backend engineering + RAG/search + agent orchestration + cloud delivery + evaluation and observability + security and reliability.

This study manually codes 60 recent public JDs: 20 each from mainland China, the United States, and Tokyo. It covers these titles:

• AI Application Engineer
• AI Agent / Agentic AI Engineer
• RAG Engineer
• Generative AI Engineer
• Applied AI Engineer
• AI Backend Engineer
• AI/LLM Engineer
• Forward Deployed / AI Solutions Engineer

Across the three markets, the most frequent technical directions are:

1. Python
2. Agents, tool calling, and workflow orchestration
3. RAG
4. Backend, APIs, and microservices
5. LangChain
6. Vector retrieval, embeddings, and search
7. Evaluation, observability, and LLMOps
8. LangGraph
9. Cloud platforms such as AWS, Azure, and GCP
10. Prompt / context engineering

Hiring frequency is not learning order. For an engineer targeting Tokyo, the recommended priority is:

Python/FastAPI → production RAG → LangChain v1/LangGraph v1 → AWS → PostgreSQL/OpenSearch → evaluation/observability → Docker/Terraform/CI/CD → agent safety and human-in-the-loop.

1. Research scope and method

1.1 Sample scope

The sample is split into three markets:

The research date is July 28, 2026. A job page may be closed, reposted, or changed when a reader visits it, so this article is a snapshot of the market at the research date, not permanent data.

1.2 Role-inclusion criteria

Included:

• Roles whose core responsibilities are LLM applications, AI agents, RAG, or generative-AI products.
• Roles requiring engineering implementation, systems integration, deployment, or production operations.
• Roles highly related to AI Application, Agent, RAG, Applied AI, or AI Backend work.

Excluded:

• Pure computer-vision roles.
• Pure traditional machine-learning, recommendation, or data-analysis roles.
• Pure foundation-model pretraining research.
• Pure sales, presales, or roles without practical development responsibility.
• Roles that mention ChatGPT or Copilot only as office tools rather than as products to be engineered.

1.3 Counting rules

Each JD is counted at most once for a technical category. A capability is counted only when the role description, stack, required qualifications, or preferred qualifications explicitly names it.

For example:

• FastAPI, REST API, and 微服务 are grouped as “backend/API/microservices.”
• Pinecone, Milvus, Qdrant, FAISS, OpenSearch, and pgvector are grouped as “vector retrieval/embeddings/search.”
• LangSmith, Langfuse, OpenTelemetry, evaluation harness, and tracing are grouped as “evaluation/observability/LLMOps.”
• tool use, function calling, multi-agent, and orchestration are grouped as “agents/tool calling/orchestration.”

1.4 How to interpret percentages correctly

Each market has 20 samples, so one JD equals five percentage points. A five-to-ten-point difference should not be overinterpreted as an absolute ranking; it is better treated as the same tier.

These figures are:

Appearance rates in a recent public-JD sample.

They are not:

• A census share of every role in an entire country.
• An exact measure of how mandatory a skill is.
• A fixed forecast for future years.
• Official hiring-platform statistics.

The study itself focuses on agent, RAG, and AI-application roles, so those directions naturally appear more often than in the broad AI employment market.

2. Technical frequency across the three combined markets

2.1 Combined ranking of 60 JDs

2.2 What this data actually says

An AI Application Engineer is first a software engineer

The high frequency of Python, backend/API work, databases, cloud, Docker, and CI/CD shows that companies do not want only people who can experiment in notebooks. They need engineers who can:

• Wrap model capability in stable APIs.
• Integrate with databases, enterprise systems, and third-party SaaS.
• Handle concurrency, timeouts, retries, and failures.
• Deploy to the cloud.
• Monitor cost, latency, and quality.
• Own production outcomes.

Agents have moved from a demo concept to an engineering keyword

Many JDs no longer stop at a simple chatbot; they explicitly ask for:

• Tool calling / function calling.
• Planning.
• Memory and state.
• Multi-step workflows.
• Multi-agent systems.
• Retry / repair loops.
• Human-in-the-loop.
• Enterprise API, database, CRM, email, and ticketing integration.

RAG remains the most stable and widespread enterprise use case

Enterprise data usually cannot simply be given to a general model, nor is model-parameter memory an appropriate substitute. RAG therefore remains the most stable entry skill for AI application roles.

Enterprise RAG is not only “a vector database plus an LLM”; it is:

数据接入
→ 文档解析与清洗
→ Chunking
→ Metadata 与权限
→ Embedding
→ Dense/BM25/Hybrid Retrieval
→ Rerank
→ Context 构造
→ 带引用回答
→ 离线与在线评测
→ 监控与持续优化

Evaluation and observability are becoming the production dividing line

This capability is especially prominent in the US sample. Companies increasingly ask for:

• Golden datasets.
• Regression suites.
• Task-success rate.
• Retrieval evaluation.
• Tracing.
• Failure taxonomies.
• Cost / latency metrics.
• Prompt and model versioning.
• Release gates.
• A/B tests.
• Guardrail thresholds.

Many people can make a demo. People who can demonstrate why a system is reliable and how it continues improving are still scarce.

3. Mainland China: application delivery, private deployment, and domestic-model ecosystems

3.1 Technical frequency in 20 mainland-China JDs

Recent mainland-China JDs often place FastAPI, LangChain/LangGraph, RAG, vector databases, PostgreSQL, Docker, MCP, function calling, and evaluation in the same role. Wuhan Lingdian’s agent-engineer role is a typical combination: Python, FastAPI, LangChain, LangGraph, Weaviate/Pinecone/Milvus, PostgreSQL, Docker, CI/CD, MCP, and OpenTelemetry all appear together.¹

3.2 Three pronounced characteristics of the China market

Characteristic 1: domestic models, private deployment, and inference delivery appear more often

China-based roles are more likely to explicitly mention:

• Qwen / Tongyi Qianwen.
• DeepSeek.
• GLM / Zhipu.
• Dify, Coze, n8n.
• vLLM, SGLang, LMDeploy.
• LoRA / QLoRA.
• Local model serving.
• GPU-server management.
• Private knowledge bases.

That explains why fine-tuning, model deployment, and inference optimization reach 40% in the China sample, noticeably higher than in the Tokyo AI Application sample.

A ChinaSoft International JD simultaneously asks for Java/Python, LangChain, Spring AI, LangGraph, MCP, Milvus, Neo4j, reranking, Qwen, GLM, DeepSeek, LoRA/QLoRA, and vLLM. It reflects the common combination in large Chinese enterprises: “AI applications + domestic models + existing Java business systems.”²

Characteristic 2: Java still has practical value

In traditional enterprises, finance, insurance, manufacturing, government, and systems-integration projects in China, AI modules often must connect to:

• Spring Boot.
• Spring Cloud.
• Spring AI.
• MyBatis.
• MySQL / OceanBase.
• Redis / RabbitMQ.
• Existing microservice estates.

Python is the main language for AI applications, but Java has not lost its value. For engineers with a Java-backend background, the sensible strategy is not to abandon Java but to make the split explicit:

Python handles AI/RAG/agent services; Java handles existing core business systems and enterprise integration.

Characteristic 3: low-code agent platforms are delivery tools, not the core advantage

Dify, Coze, n8n, and RAGFlow appear regularly in China JDs. They suit:

• Fast proof of concept.
• Business-process experiments.
• Non-core workflows.
• Client demonstrations.
• Internal automation.

The high-value differentiators in hiring are still:

• Whether you can implement maintainable agents in code.
• Whether you can build retrieval and evaluation.
• Whether you can manage state, retries, permissions, and exceptions.
• Whether you can integrate enterprise APIs and databases.
• Whether you can deploy and operate the system.

Only dragging nodes in a platform is not enough for a production AI Application Engineer.

4. United States: the highest bar for evaluation, reliability, safety, and system design

4.1 Technical frequency in 20 US JDs

EXL’s Agentic AI Engineer role is representative: beyond Python, LangChain, LangGraph, RAG, vector databases, FastAPI, microservices, and cloud, it explicitly asks for an evaluation harness, tracing, metrics, rollback, guardrails, auditability, HITL, CI/CD, and PII/PHI security.³

4.2 Four pronounced characteristics of the US market

Characteristic 1: frameworks are a means; production-system capability is the hard bar

US roles often use wording such as:

• shipped to production;
• production ownership;
• measurable improvement;
• task success rate;
• reliability / latency / cost;
• failure taxonomy;
• regression suite;
• distributed systems;
• idempotency;
• auditability.

This means an interviewer will not only ask whether you know LangGraph. They can ask:

• A tool completed successfully but the LLM request timed out. How do you prevent duplicate execution?
• How do you resume an agent after it fails midway?
• How do you define task-success rate?
• How do you separate retrieval errors from generation errors?
• How do you roll out gradually and roll back?
• How do you constrain an agent’s permissions?
• How do you monitor cost, latency, and failure modes?

The General Intelligence Company role explicitly asks for retry/backoff, idempotency, auditability, agent memory/context routing, OpenTelemetry/Datadog, and offline and online evaluation.⁴

Characteristic 2: evaluation is core development work, not an afterthought

Many US roles put evaluation directly in the core job:

Golden tasks
Regression suites
Behavior tests
Online metrics
A/B tests
Canary releases
Guardrail thresholds
Failure analysis

Amtex’s Coding Agent role even lists an evaluation harness, failure taxonomy, tracing, metrics, alerts, and release gates as hard requirements.⁵

Characteristic 3: safe, constrained autonomy matters more than “fully autonomous” agents

Enterprise agents touch CRM, financial data, identity systems, email, databases, and production APIs. US roles often explicitly require:

• Human-in-the-loop.
• Guardrails.
• Audit trails.
• Compliance.
• PII/PHI protection.
• Identity and access management.
• Constrained autonomy.
• Safe tool use.

An excellent Agent Engineer is therefore not someone who makes an agent do as much as possible; it is someone who knows:

Which actions may run automatically, which require approval, and which must be prohibited.

Characteristic 4: US roles may not name one framework, but they name the underlying capabilities

Some startups do not mandate LangChain or LangGraph. Instead, they ask for:

• Tool orchestration.
• Memory architecture.
• Retrieval.
• Evaluation.
• Retry/repair loops.
• Context routing.
• Backend reliability.

Those roles may permit a custom runtime, OpenAI Agents SDK, Google ADK, PydanticAI, or another framework. Do not merely memorize the LangGraph API; understand the underlying engineering problems of an agent runtime.

5. Tokyo: Python, cloud, and end-to-end delivery matter most

5.1 Technical frequency in 20 Tokyo JDs

Future explicitly lists Python, LangChain, LangGraph, Amazon Bedrock, and Azure OpenAI, and asks for end-to-end ability from business-process redesign and technical validation through RAG-accuracy improvement, architecture design, and implementation.⁶

FLARETECH’s generative-AI role combines Python, RAG, vector databases, LangChain/LangGraph, evaluation, guardrails, LLMOps, AWS, and Docker—evidence of Tokyo’s expectation that engineers can take work from prototype to production.⁷

5.2 Why Tokyo ranks cloud platforms so highly

Cloud-platform mentions in the Tokyo sample are below. A single role can list several clouds, so the percentages total more than 100%.

Common combinations include:

AWS Bedrock
AWS OpenSearch
S3
RDS PostgreSQL
ECS / Fargate
Lambda
Azure OpenAI Service
Azure AI Search
Vertex AI
Cloud Run
BigQuery

Many Tokyo AI projects come from:

• Enterprise digital transformation.
• Generative-AI consulting and systems integration.
• Internal knowledge bases.
• Customer service and business automation.
• Finance, manufacturing, and human resources.
• Existing SaaS products adding AI capabilities.

These projects must connect enterprise data and existing systems. “Knowing how to use a model” is far from enough; employers care whether an engineer can deploy, operate, and deliver a system to real users.

5.3 Tokyo values proof-of-concept-to-production delivery, not pure research

In the Tokyo sample:

后端/API/微服务：70%
云平台：90%
微调/推理优化：10%

For AI Application, Agent, and RAG roles, this indicates stronger demand for:

Software engineers who can integrate AI features into real products, complete a proof of concept, launch it, monitor it, and iterate.

nineDots’ Tokyo Applied AI role asks for Python, CI/CD, Terraform, containers, RAG, prompts, fine-tuning, LangChain, Pinecone, Hugging Face, LLMOps, and vector databases. It emphasizes experience taking generative AI from prototype to real users.⁸

5.4 Language expectations differ between Japanese companies and Japan offices of US companies

Language is not a technology stack, but it is a real screening criterion in Tokyo.

Japan-client, systems-integration, and FDE roles

They often require:

• Business-level Japanese communication.
• Japanese requirements definition.
• Japanese technical documentation.
• Japanese proof-of-concept work and customer reporting.
• JLPT N2/N1 or an equivalent level.

TempestAI explicitly asks for the ability to conduct requirements definition and technical documentation in Japanese.⁹

International product teams and US-company roles in Japan

English may be the primary working language:

• BJAK Japan states that English is the main working language for its global team.¹⁰
• Cookpad’s international role says Japanese is not required and business-level English is required.¹¹
• Robert Half’s Tokyo RAG role says Japanese is not required.¹²

International companies serving Japanese clients may still require bilingual skills. Zoom’s Tokyo Applied AI Engineer role asks for fluency in both Japanese and English, including deploying AI agents from proof of concept to a client production environment during the sales cycle.¹³

Tokyo roles can therefore be roughly divided as follows:

6. What the different job titles are actually hiring for

6.1 AI Application Engineer

The core task is to turn model capability into a business feature.

Common requirements:

• Python.
• FastAPI / Flask.
• LLM APIs.
• RAG.
• Tool calling.
• Databases and enterprise APIs.
• Cloud deployment.
• Testing and monitoring.

In essence:

A backend/product engineer who understands AI.

6.2 AI Agent / Agentic AI Engineer

On top of AI Application Engineer capability, this title puts more weight on:

• Agent loops.
• Tool use.
• Planning.
• Memory and state.
• LangGraph or another orchestration framework.
• Multi-agent systems.
• Retry / recovery.
• Human-in-the-loop.
• Guardrails.
• Evaluation.

In essence:

A backend/platform engineer who designs and runs controlled autonomous systems.

6.3 RAG Engineer

This title emphasizes data, search, and quality optimization:

• Document parsing.
• Chunking.
• Embeddings.
• Vector databases.
• BM25 / hybrid search.
• Reranking.
• Metadata / ACLs.
• Citations.
• Retrieval evaluation.
• Data updates and index maintenance.

In essence:

A cross-disciplinary role spanning search engineering, data engineering, and LLM applications.

6.4 Applied AI Engineer

This title is common at US and international companies and usually expects end-to-end ownership:

• Identify valuable AI use cases.
• Prototype quickly.
• Design evaluation.
• Implement for production.
• Work with product teams and customers.
• Continuously measure business outcomes.

It usually emphasizes product delivery more than a pure algorithm-engineer title and model behavior and evaluation more than an ordinary backend-engineer title.

6.5 Forward Deployed Engineer / AI Solutions Engineer

These roles deserve particular attention in Tokyo and at Japanese offices of US companies.

Their core capability is:

客户问题
→ 需求澄清
→ 技术方案
→ PoC
→ 数据和系统集成
→ 生产上线
→ 培训与持续改进

In addition to technology, they require:

• Communication.
• Requirements analysis.
• Architectural explanation.
• Business understanding.
• Japanese and/or English.
• Ownership of delivery results.

7. The capability model a candidate should have

A qualified AI Application / Agent / RAG Engineer should not be merely a collection of framework names. The capabilities should form the following eight layers.

Layer 1: production software engineering

You must have:

• Python type annotations.
• async / await.
• Tests.
• Logging and exception handling.
• API design.
• Concurrency and task queues.
• Databases.
• Git.
• Code review.
• System design.
• Foundations of performance and reliability.

Layer 2: LLM application foundations

You must understand:

• Messages and context.
• Tool calling.
• Structured output.
• Tokens and context windows.
• Model selection and routing.
• Prompt / context engineering.
• Streaming.
• Caching.
• Cost and latency.

Layer 3: production RAG

You must be able to implement and optimize, from scratch:

• Ingestion.
• Parsing.
• Chunking.
• Metadata.
• Embeddings.
• Retrieval.
• Reranking.
• Context assembly.
• Citations.
• ACLs.
• Evaluation.

Layer 4: agent runtime

You must understand:

• ReAct.
• State.
• Planning.
• Tools.
• Memory.
• Checkpoints.
• Interrupts.
• Retries.
• Idempotency.
• Human approval.
• Sub-agents.
• Long-running tasks.

Layer 5: evaluation and observability

You must be able to answer:

• How do we define success?
• How do we build a test set?
• How do we run regression checks?
• How do we locate whether a failure is in retrieval, prompts, the model, or a tool?
• How do we trace every agent step?
• How do we monitor cost, latency, and failure rate?

Layer 6: cloud and deployment

Master at least one complete path:

FastAPI
→ Docker
→ Container Registry
→ ECS/Fargate 或 Cloud Run
→ PostgreSQL
→ Object Storage
→ Vector/Search Service
→ Monitoring
→ Secrets

Layer 7: security and governance

You must understand:

• Prompt injection.
• Tool permissions.
• Secrets.
• PII.
• Audit logs.
• Tenant isolation.
• Read/write permission tiers.
• HITL.
• Sandboxes.
• Rate limits.
• Timeouts.
• Idempotency.

Layer 8: business and product delivery

Companies do not hire merely to “use agents.” They hire to:

• Improve efficiency.
• Lower costs.
• Improve retrieval accuracy.
• Automate processes.
• Help customers make decisions.
• Increase product revenue.

Candidates must connect technical metrics to business value.

8. How to prioritize the technical stack for a Tokyo job search

The priorities below jointly consider:

• Frequency in Tokyo JDs.
• Prerequisite relationships between technologies.
• Learning investment and hiring return.
• Whether a portfolio can prove the ability.
• Transferability across China, the US, and Japan.

P0: production Python backend

Recommended technologies

Python 3.12+
uv
FastAPI
Pydantic v2
asyncio
pytest
Ruff
mypy / pyright
REST API
SSE / Streaming
WebSocket 基础

Required capability

Not merely “writing scripts,” but independently completing:

• A layered project structure.
• Pydantic schemas.
• Dependency injection.
• Asynchronous APIs.
• Streaming.
• Unit and integration tests.
• Exceptions and retries.
• Logging and trace IDs.
• PostgreSQL transactions.
• Redis / queue foundations.
• Performance and concurrency investigation.

Why it ranks first

Python appears in 95% of the combined sample, 95% of Tokyo JDs, and 100% of the US sample. It is the most stable shared language for AI Application roles.

P0: production RAG

Recommended technologies

PostgreSQL + pgvector
OpenSearch
Qdrant
Redis
Embedding
BM25
Hybrid Search
Reranker
Metadata Filter
Citation
ACL

Required capability

You should be able to explain and implement the complete flow:

文档解析
→ 切片
→ 索引
→ 召回
→ 重排
→ 上下文构造
→ 生成
→ 引用
→ 评测

You should also be able to answer:

• How should chunk size be chosen?
• How should tables and PDFs be handled?
• Why does dense retrieval miss relevant material?
• How should BM25 and vector retrieval be combined?
• Where should a reranker be placed?
• How do you handle document-version updates?
• How do you prevent retrieval of documents without permission?
• How do you evaluate Recall, MRR, NDCG, and faithfulness?

Recommended Tokyo database combination

Prioritize:

PostgreSQL/pgvector + OpenSearch

Keep Qdrant as experience with a standalone vector database.

PostgreSQL is general enterprise infrastructure; OpenSearch closely matches the Tokyo market’s frequent AWS, enterprise-search, and hybrid-RAG requirements.

P0: LangChain v1 + LangGraph v1

Focus areas for LangChain v1

Model
Message
Tool
Structured Output
Middleware
Runtime Context
create_agent
MCP Integration
Provider Integration

Do not spend large amounts of time on the old Chain API.

Focus areas for LangGraph v1

State
Node / Edge
Command
Checkpoint
thread_id
Interrupt
Resume
Retry
Subgraph
Store
Durable Execution
Idempotency
Human-in-the-loop

Why the two must be combined

LangChain handles models, messages, tools, and the standard agent interface.

LangGraph handles production-agent concerns:

• State.
• Interrupts.
• Resumption.
• Persistence.
• Approval.
• Long-running tasks.
• Complex workflows.

Where Deep Agents fit

Deep Agents do not yet appear as a frequent hiring keyword in this sample.

The sensible order is:

LangChain v1 基础
→ LangGraph v1 Runtime
→ 生产级 Agent Engineering
→ Deep Agents

Deep Agents are worth learning for planning, filesystems, sub-agents, skills, and context management, but they do not replace understanding LangGraph.

P0: AWS

Suggested cloud priority for Tokyo:

AWS
>
Azure
>
GCP

Learn AWS first

IAM
S3
Bedrock
OpenSearch
RDS PostgreSQL
ECS / Fargate
Lambda
CloudWatch
Secrets Manager
VPC 基础

Recommended deployment path

FastAPI / LangGraph
        ↓
Docker
        ↓
ECR
        ↓
ECS Fargate
        ↓
RDS PostgreSQL
        ↓
OpenSearch
        ↓
S3
        ↓
Bedrock
        ↓
CloudWatch

Second-stage Azure focus:

Azure OpenAI Service
Azure AI Search
Azure Container Apps
Azure Database for PostgreSQL
Azure Monitor

Second-stage GCP focus:

Vertex AI
Cloud Run
Cloud SQL
BigQuery
Cloud Storage

P1: evaluation, observability, and LLMOps

At minimum, master

Golden Dataset
Prompt Versioning
Trace
Token Usage
Latency
Tool Success Rate
RAG Recall
Faithfulness
Agent Task Success Rate
Regression Test
Cost Monitoring
Failure Taxonomy

Tool selection

You do not need to learn every product. Choose one stack deeply:

Langfuse 或 LangSmith
+
OpenTelemetry

You can add:

Ragas
DeepEval
Promptfoo
Phoenix

A portfolio must show

• A trace for every agent run.
• Model and prompt versions.
• Every tool call.
• Tokens, cost, and latency.
• A fixed evaluation set.
• Regression results after changing retrieval or prompts.
• Failure-sample classification.

P1: Docker, CI/CD, and Terraform

Recommended order:

Docker
→ Docker Compose
→ GitHub Actions
→ Terraform
→ AWS ECS/Fargate
→ Kubernetes 基础

For most AI Application roles, being able to deploy a service reliably to AWS with Docker, Terraform, and GitHub Actions is more valuable than deeply memorizing Kubernetes internal APIs.

P1: agent safety, HITL, and reliable execution

You must master:

Prompt Injection
Tool Permission
Read/Write 权限分级
Human Approval
Secrets Management
PII
Audit Log
Timeout
Retry
Idempotency
Rate Limit
Tenant Isolation
Sandbox

Recommended risk policy:

读取操作
→ 可以在明确范围内自动执行

写入操作
→ 根据风险请求批准

发送邮件、发布、部署、删除、付款
→ 必须明确审批或强策略限制

This area is especially important in US roles and is a valuable Tokyo-portfolio differentiator.

P2: MCP

MCP appears in roughly 15% of the combined sample. It has entered hiring language but is not yet a P0 skill.

You should master:

• MCP servers / clients.
• Tools.
• Resources.
• Prompts.
• Transports.
• Authentication.
• Credential isolation.
• Permission control.

You must understand:

MCP standardizes tool and context integration; it does not provide an agent state machine, reliable execution, evaluation, or permission governance.

P2: TypeScript and a simple product interface

TypeScript/JavaScript appears in 35% of Tokyo samples. You do not need to become a professional frontend engineer, but should be able to:

• Read and modify TypeScript.
• Use React / Next.js.
• Build an agent chat UI.
• Show streaming.
• Show tool calls.
• Show traces.
• Show approvals.
• Build a simple management console.

Recommended:

TypeScript
React
Next.js
基础 Tailwind CSS

P2: model fine-tuning and inference optimization

Only about 10% of Tokyo AI Application samples explicitly require fine-tuning, inference optimization, or local-model deployment.

You should therefore understand:

SFT
LoRA / QLoRA
DPO
Quantization
vLLM
SGLang

You do not need to spend months training models at the start of a job search unless your target is:

• LLM Engineer.
• Model Engineer.
• ML Platform Engineer.
• Inference Engineer.
• Foundation Model Researcher.

For AI Application, Agent, and RAG roles, production backends, RAG, evaluation, and cloud deployment usually produce a higher return.

9. Customized stacks for different target markets

9.1 Japanese local companies in Tokyo

Python
FastAPI
LangChain v1
LangGraph v1
RAG
PostgreSQL
OpenSearch
AWS Bedrock
ECS/Fargate
Docker
Terraform
Langfuse/OpenTelemetry
日语需求分析和技术说明

Demonstrate that you can:

• Turn a client problem into a proof of concept.
• Launch that proof of concept.
• Write Japanese design documentation.
• Explain cost, quality, and risk.
• Integrate with existing systems.

9.2 Japan offices of US companies

Python
System Design
Agent Runtime
RAG
Evaluation Harness
Observability
Guardrails
HITL
Distributed Systems
Cloud
CI/CD
英文技术沟通
日语客户沟通（客户型岗位）

Demonstrate:

• Production ownership.
• Measurable improvements.
• Evaluation and regression.
• Security boundaries.
• Failure recovery.
• Cost and latency optimization.
• English design documents.

9.3 Mainland-China companies

Python
FastAPI
LangChain/LangGraph
RAG
Milvus/Qdrant
国产模型 API
Dify/Coze/n8n
Docker/Kubernetes
vLLM/SGLang 基础
Java/Spring Boot/Spring AI 集成
私有化部署

Demonstrate:

• Domestic-model adaptation.
• Enterprise knowledge bases.
• Private deployment.
• Java business-system integration.
• Model deployment.
• Delivery speed.

10. A complete stack best suited to a Tokyo job search

Core development

Python 3.12+
uv
FastAPI
Pydantic v2
pytest
asyncio
REST / SSE
Ruff
mypy / pyright

Agents

LangChain v1
LangGraph v1
Structured Output
Tool Calling
Checkpoint
Interrupt / Resume
Human-in-the-loop
MCP

RAG and data

PostgreSQL
pgvector
OpenSearch
Qdrant
Redis
Hybrid Search
Reranker
Citation
ACL
Document Versioning

Cloud and deployment

AWS Bedrock
S3
OpenSearch
RDS
ECS / Fargate
IAM
CloudWatch
Secrets Manager
Docker
Terraform
GitHub Actions

Evaluation and observability

Langfuse 或 LangSmith
OpenTelemetry
RAG Evaluation
Agent Evaluation
Regression Dataset
Cost / Latency Monitoring

Presentation layer

TypeScript
Next.js
简单 Agent UI

Differentiating capabilities

Java / Spring Boot 企业系统集成
日语业务沟通
生产级 Agent 安全与审批
RAG 评测与回归
AWS 部署
英文技术文档

11. How to allocate learning time

An executable 20-week roadmap

Weeks 1–4: production Python backend

Deliverables:

• A FastAPI project.
• PostgreSQL.
• Asynchronous APIs.
• Tests.
• Docker.
• Streaming.
• Logging and error handling.

Weeks 5–8: production RAG

Deliverables:

• PDF/Word/HTML ingestion.
• pgvector or Qdrant.
• BM25 + dense hybrid.
• A reranker.
• Citations.
• Metadata filtering.
• An evaluation dataset.

Weeks 9–12: LangChain v1 and LangGraph v1

Deliverables:

• A tool-calling agent.
• StateGraph.
• Checkpoints.
• Interrupts.
• Human approval.
• Retries.
• Multi-step tasks.
• Recoverable runs.

Weeks 13–16: AWS and deployment

Deliverables:

• A Docker image.
• ECS/Fargate.
• RDS.
• S3.
• OpenSearch.
• Bedrock.
• Terraform.
• GitHub Actions.
• CloudWatch.

Weeks 17–20: evaluation, safety, and job-search packaging

Deliverables:

• Langfuse/OpenTelemetry traces.
• RAG regression.
• Agent task-success rate.
• Prompt-injection tests.
• Tool permissions.
• Audit logs.
• Bilingual Japanese-English README.
• System-design documentation.
• A demo video.

12. The most worthwhile job-search portfolio

Instead of building five simple chatbots, build one complete:

Enterprise bilingual Japanese-English RAG + Agent platform

12.1 Architecture

PDF / Word / HTML / 企业数据
             ↓
解析、清洗、切片、版本管理
             ↓
OpenSearch + pgvector/Qdrant 混合检索
             ↓
Reranker
             ↓
带页码、来源和权限的回答
             ↓
LangGraph Agent
             ↓
GitHub / Gmail / Calendar / MCP Tools
             ↓
写操作 Human Approval
             ↓
PostgreSQL Checkpoint
             ↓
Langfuse / OpenTelemetry
             ↓
AWS 部署

12.2 Required capabilities

• Japanese and English documents.
• Document-version management.
• ACL permission filtering.
• Hybrid search.
• A reranker.
• Citations.
• LangGraph checkpoints.
• Interruption and resumption.
• Approval for write tools.
• Idempotency.
• Multi-user isolation.
• Traces.
• Evaluation.
• Docker.
• Terraform.
• GitHub Actions.
• An AWS architecture diagram.

12.3 Metrics that must be quantified

Do not only show an interface. Show:

Retrieval Recall@K
MRR / NDCG
Answer Faithfulness
Citation Accuracy
Agent Task Success Rate
Tool Failure Rate
P95 Latency
Token Cost
Recovery Success Rate

12.4 Questions the README must answer

• Why was this architecture chosen?
• Why OpenSearch + pgvector/Qdrant?
• How is unauthorized retrieval prevented?
• How are retrieval failures separated from generation failures?
• How are interrupted agents resumed?
• How are duplicate write operations prevented?
• How is the system evaluated?
• How is it deployed?
• What are its current limitations?
• How can it be extended next?

This one project can cover most technologies that appear frequently in Tokyo roles:

Python
FastAPI
AWS
Agent
RAG
LangChain
LangGraph
向量搜索
SQL
Docker
Terraform
CI/CD
Evaluation
Observability
MCP
Security / Approval

13. Questions you must be able to answer in an interview

Python and backend

• When does async/await genuinely improve throughput?
• How do you implement an LLM streaming API?
• How should a FastAPI service handle timeouts, cancellation, and retries?
• How do you design an idempotent API?
• How do you handle long-running agent tasks?

RAG

• Why is vector search alone insufficient?
• How does chunking affect recall?
• How do you design hybrid search?
• What are a reranker’s inputs and outputs?
• How do you evaluate retrieval?
• How do you implement citations and ACLs?
• How do you prevent old versions from contaminating results after a document update?

Agents

• What is the difference between tool calling and a workflow?
• What is the relationship between LangChain and LangGraph?
• What does a checkpoint save?
• How do you continue after an interrupt?
• What happens if a tool has executed but the node fails?
• When should you use multi-agent systems?
• How do you prevent an agent from looping forever?
• How do you restrict tool permissions?

Evaluation

• How is agent success rate defined?
• How do you build a golden dataset?
• How do you run prompt regression?
• How do you locate whether failure belongs to the model, retrieval, or a tool?
• How do you conduct offline evaluation and online monitoring?
• How do you set a release gate?

Cloud and production

• Why choose ECS/Fargate rather than Lambda or Kubernetes?
• How are secrets managed?
• How are logs, traces, and metrics correlated?
• How is cost controlled?
• How do you do rolling releases and rollbacks?
• How do you design multi-tenant isolation?

14. Common learning mistakes

Mistake 1: learning ten agent frameworks at once

Do not try to learn all of these deeply at the same time:

LangGraph
CrewAI
AutoGen
Agno
PydanticAI
Google ADK
OpenAI Agents SDK
Deep Agents
Semantic Kernel
Strands

Master this first:

LangChain v1
+
LangGraph v1
+
Agent Engineering 原理

Then migrate according to a company’s stack.

Mistake 2: treating prompt engineering as a separate career moat

Prompts matter, but companies value:

• Whether prompts are versionable.
• Whether they can be evaluated.
• Whether they can be regression tested.
• Whether structured output is present.
• Whether prompts work with tools, RAG, and business rules.
• Whether cost and failure rate can be controlled.

Mistake 3: knowing only Dify or Coze

Low-code platforms suit proof of concept, but do not replace:

• Python.
• APIs.
• Databases.
• State management.
• Tests.
• Permissions.
• Deployment.
• Observability.

Mistake 4: investing in fine-tuning too early

For AI Application, Agent, and RAG roles, bringing the following to production quality usually has more job-search value than training a model first:

后端
RAG
Agent
Evaluation
Cloud

Mistake 5: a portfolio that can only chat

A chat interface cannot prove:

• Reliability.
• Evaluation.
• Safety.
• System design.
• Deployment.
• Business value.

A portfolio must demonstrate failure handling, metrics, and architectural trade-offs.

15. Conclusion

The 2026 AI-application job market has formed a clear main line:

Companies do not truly need “people who can call a model.” They need people who can turn uncertain model capability into stable, evaluable, auditable, and deployable business systems.

The shared technical foundation across mainland China, the US, and Tokyo is:

Python
+
RAG
+
Agent
+
后端/API
+
向量检索
+
Evaluation/Observability
+
Cloud/Deployment

Regional differences are:

• Mainland China places more weight on domestic models, private deployment, Java business-system integration, and inference delivery.
• The US places more weight on evaluation, reliability, guardrails, system design, and production ownership.
• Tokyo places more weight on Python, AWS, backend delivery, client delivery, and complete proof-of-concept-to-production capability.
• Japan offices of US companies commonly require both US-style engineering quality and the communication and delivery expectations of the Japanese market.

If your goal is an AI Application Engineer, AI Agent Engineer, or RAG Engineer role in Tokyo, the best first route is not collecting more framework names. It is becoming someone who can:

Use Python, LangGraph, RAG, and AWS to deploy AI agents safely, reliably, and evaluably to production, then explain the design trade-offs to a team and customers in Japanese or English.

Appendix A: representative public job samples in this study

The following links support verification of the technology trends. A role can close, be reposted, or change.

A.1 Mainland China

1. Wuhan Lingdian: Python Agent Engineer (AI Applications)
2. Runjian: AI Application Development Engineer
3. Shenzhen Zhongmai: Python (RAG/AI Agent)
4. Chongqing Dianming: AI Agent R&D Engineer
5. Liaoning Lianwei Yizhong: AI Agent Development Engineer
6. ChinaSoft International: AI Foundation-Model Application Engineer
7. Boyachuangzhi: AI Algorithm Engineer
8. Shanghai Kuanwen Shifeng: AI Development Engineer
9. Hualing Holdings: Python Development Engineer — AI Applications
10. Zhongtian Holdings: Foundation-Model Application Development Engineer
11. Zhongchuangshi: Foundation-Model Application Engineer
12. Shenzhen: AI Agent Engineer
13. Nippon Paint China: AI Agent Development Engineer
14. Shanghai: AI Agent Development Engineer
15. Ningbo International Logistics: Senior AI Application Development
16. Beijing Hualong Hongda: AI Application Development Engineer
17. Keda Guochuang: AI Development Engineer
18. Shendeke: AI Application Development Engineer
19. Zhejiang Rongtu: AI Application Engineer
20. Guangdian Metrology: AI Agent Development Engineer

A.2 United States

1. EXL: Agentic AI Engineer
2. Amtex Systems: AI Agent Engineer
3. Joveo AI: AI Agent Engineer
4. Lumos: AI Agent Engineer
5. QODE: AI / Agent Engineer
6. Ditto.ai: Applied AI Engineer
7. Curie: AI Engineer
8. The General Intelligence Company of New York: Applied AI Engineer—Agent
9. Pulsora: Applied AI Engineer—US
10. BJAK: Applied AI Engineer—US
11. Rowspace: Applied AI Engineer
12. Amigo: Applied AI Engineer
13. CodeRabbit: Applied AI Engineer
14. Sapien: Applied AI Engineer
15. Taktile: Senior Applied AI Engineer
16. HackerOne: Staff Software Engineer, Applied AI
17. Nimble Gravity: Senior AI Engineer
18. SBT Global: Senior Generative AI Engineer
19. Woongjin: Senior Gen AI Engineer
20. Leorna: Lead AI Architect and Engineer

A.3 Tokyo and Japan market

1. Future: AI・LLM Engineer
2. renue: AI・LLM Engineer
3. FLARETECH: Generative AI Engineer (LLM/RAG)
4. kubell: AI Solution Engineer
5. Mindia: Python × LLM Full-stack Engineer
6. Upgrade: AI Engineer—Agent/RAG
7. Algomatic: AI/ML Engineer—AI Agent
8. Rakus: AI Development Tech Lead
9. CARTA HOLDINGS: AI Engineer
10. Genie: LLM/RAG Backend Engineer
11. Emuni: AI/LLM Engineer
12. TempestAI: LangGraph Multi-Agent Engineer
13. HEROZ: Backend Engineer—AI Agent
14. Robert Half: AI Engineer (RAG)
15. BJAK: Applied AI Engineer—Japan
16. nineDots: Senior Applied AI Engineer
17. Cookpad: Principal Applied AI Engineer
18. Kaigen: AI Software Development Engineer
19. Zoom: Applied AI Engineer—Tokyo
20. ExaWizards: AI Solution Engineer

Appendix B: citations in the article