HR & 行为面试
第一轮和管理层轮均会问。用 STAR 框架（Situation / Task / Action / Result）来结构化回答。
已查看 0 / 10
↓ 按可能性从高到低排序 — 越靠上越重要
准备 2–3 个好问题（体现主动性，非常重要）：
- "What does a typical week look like for an AI Agent intern on this team?"
- "Are there existing LangGraph or LLM-based systems in production at Binance that I'd be contributing to, or is the role more greenfield?"
- "What are the biggest technical challenges the team faces with AI agent reliability at Binance's scale?"
- "How does Binance think about the trade-off between moving fast with AI features and ensuring safety for financial users?"
💡 Tip: 永远不要说"No, I think you've covered everything." 这是你最后展示思考深度的机会。
建议结构（60–90 秒）：
- 背景：I'm a Computer Science student with a strong focus on AI systems and backend engineering.
- 核心项目：Most recently I built an ASX multi-agent chatbot using LangGraph — it orchestrates several AI agents to retrieve and analyse Australian stock data in real time, with a streaming frontend that visualises the agent execution graph as it runs.
- 技术栈：The stack includes Python, LangGraph, RAG-based retrieval, a TypeScript frontend, and a streaming layer.
- 为什么 Binance：I'm now looking to apply these skills at the intersection of AI and real financial infrastructure — which is exactly what the Binance Accelerator Program offers.
💡 Tip: 不要背稿，要像和朋友说话一样自然。结尾直接过渡到"为什么 Binance"。
三个角度展开：
- 规模与影响力：Binance serves 300 million users across 100+ countries. Any AI system I help build has immediate, massive real-world impact — that's rare at this career stage.
- AI + Finance 交叉点：I've been building AI agents for financial data analysis — Binance is one of the few places where agentic AI is directly applied to live trading infrastructure and user products.
- Web3 的信念：I believe decentralised finance genuinely expands financial access for people excluded from traditional banking. Working at Binance means contributing to that mission.
💡 Tip: 避免说"because it looks great on a resume"。面试官想听到你对 crypto/Web3 的真实理解。
用 ASX 项目的真实经历：
- Situation: I needed a multi-agent orchestration layer but LangChain's standard chains couldn't handle conditional branching and state persistence.
- Task: Migrate to LangGraph within a week while keeping the existing RAG retrieval pipeline intact.
- Action: I read the LangGraph docs, built a small isolated prototype first to validate my understanding, then incrementally ported each agent node.
- Result: Migrated the entire system in 5 days. The graph structure also made it much easier to add the streaming progress panel.
💡 Tip: 强调"先做小原型验证"这个思维方式，Binance 很看重能快速迭代的工程师。
关键点：沟通、责任划分、处理分歧：
- 描述一个真实的团队经历（课程项目、黑客松、或工作经历）
- 说清楚你具体负责什么，不要只说"we did X"
- 如果有技术分歧，描述你如何用数据或 prototype 说服他人
- Result 要量化：完成了什么、学到了什么
💡 Tip: 如果缺乏团队经验，可以谈和导师合作，或参与开源 community 的经历。
- "Short-term: I want to go deep on production AI systems — understanding how to take an agent from a prototype to something that serves millions of users reliably."
- "Medium-term: I'd love to contribute to Binance's AI infrastructure as a full-time engineer after graduating."
- "Long-term: I'm interested in how AI can make financial markets more transparent and accessible for retail investors globally."
💡 Tip: 把你的目标和 Binance 的使命挂钩（financial freedom / global access）。
JD 明确说"ability to tackle ambiguous problems"，说明 Binance 特别看重这个：
- "When I started the ASX chatbot, the requirement was just 'build something useful for ASX investors.' There was no spec."
- I broke it into: (1) define 'useful' by listing 5 user stories, (2) validate the riskiest assumption first — whether LLM + ASX data actually produces reliable answers, (3) time-box explorations to 2-day spikes before committing to an architecture.
- Result: shipped a working prototype in 2 weeks because I avoided over-engineering before the core premise was validated.
💡 Tip: 面试官想看到的是：不慌张、系统拆解、快速实验、敢于决策。
诚实但有成长弧度：
- 选一个真实的弱点，但不是核心岗位技能。
- 好例子："I'm still building fluency with distributed systems and production deployment at scale — I've mostly worked with single-node setups locally."
- 然后接："I'm addressing this by studying Binance's engineering blog and experimenting with Docker and Kubernetes."
💡 Tip: 不要选假弱点（"我太努力了"）。选一个边缘技能，展示自我意识和主动学习。
要具体，不要泛泛说"I read papers"：
- 具体来源：Hugging Face Daily Papers / Simon Willison's blog / LangGraph changelogs
- 实践驱动："I try to implement something small from every major update I read — the streaming overhaul in my ASX project came from testing a new LangGraph release."
- 社群参与：GitHub discussions, Discord, Twitter/X AI community
💡 Tip: 提一个你最近读到的具体更新，来证明你真的在跟进。
- 如果你会中文："Yes, Mandarin is my first language — I'm very comfortable communicating in both English and Chinese, which I think is an asset in a global team."
- 如果英文为主："My primary language is English. I understand Binance has a strong Chinese-speaking team, and I'm open to picking up more Mandarin as I go."
💡 Tip: 中文能力是加分项，不是门槛。诚实表达即可。
项目深度问答
面试官会深挖你的 ASX Multi-Agent LangGraph Chatbot。他们想看你真正懂自己做的东西，而不只是会介绍功能。
已查看 0 / 10
↓ 按可能性从高到低排序 — 越靠上越重要
用 5 句话讲清楚：Problem → Architecture → Key decision → Frontend → Result
- Problem: Retail investors want to ask natural language questions about ASX stocks ("Is BHP overvalued?") but data is scattered across financial APIs, news feeds, and filings.
- Architecture: A LangGraph-based orchestrator routes user queries to specialised agent nodes — a retrieval agent (RAG over financial documents), a data-fetch agent (live stock prices), and a synthesis agent (LLM reasoning).
- Key decision: I chose LangGraph over simple chains because I needed stateful, conditional routing — some queries only need retrieval, others need live data + retrieval combined.
- Frontend: A TypeScript streaming UI shows the agent graph executing in real time — each node lights up as it runs.
- Result: The system can answer complex multi-source questions with RAG ensuring answers are grounded in actual documents.
💡 Tip: 画一个简单的图：User → Router → [Retrieval Node, Data Node] → Synthesis → Response。能画出来比只描述强很多。
- State persistence: A simple Python loop has no built-in state — if a node fails mid-way, you lose everything. LangGraph's checkpointer persists state after each node, enabling retry without rerunning the whole pipeline.
- Conditional routing: I needed branching logic — "if the query requires live data, route to the data agent; otherwise skip it." LangGraph's conditional edges express this cleanly.
- Streaming: LangGraph emits events per node completion, which I forward to the frontend. This enables the real-time graph visualisation.
- Query reuse: The explicit graph structure made adding a cross-cutting cache optimisation straightforward.
💡 Tip: 一定要说"我考虑过 X 方案，但选了 LangGraph 因为…"。说出你拒绝的选项，显示你做过真正的架构权衡。
过程比结果更重要。用这个结构：
- Symptom → What I initially thought → How I actually diagnosed it → Root cause → Fix
- 例子方向：GraphPanel 去重 bug（事件重复导致 UI 闪烁）、TypeScript 类型窄化引发的 dead code、status 守卫判断问题——根据你项目真实的 git history 选一个。
- 强调调试工具：structured logging, TypeScript type narrowing, event tracing.
💡 Tip: "I added logging at every node boundary, which revealed the event was emitted twice due to LangGraph's retry mechanism." 这类细节让面试官相信你真正 hands-on。
- Semantic caching: Replace exact-match cache with embedding-based similarity matching to handle paraphrased queries.
- Automated evaluation: Build an LLM-as-judge pipeline that scores responses against a golden dataset nightly.
- Re-ranking: Add a cross-encoder re-ranker between retrieval and synthesis to improve chunk precision.
- Observability: Integrate LangSmith or OpenTelemetry to visualise end-to-end latency breakdown per node.
- Auth & multi-user: The current system is single-user — proper auth and per-user conversation history would make it production-ready.
- Backend: LangGraph's
astream_events()yields events for each node start/end/error. I pipe these as Server-Sent Events to the client. - Frontend: A TypeScript component maintains a
graphStateobject tracking each node's status (pending | running | completed | error). - Rendering: Each status maps to a visual style — the node card pulses while running, turns green on completion, shows an error badge on failure.
- Deduplication: LangGraph can emit multiple events for the same node in retries — I implemented deduplication to prevent UI flickering.
💡 Tip: 如果被问"为什么用 SSE 不用 WebSocket"：SSE 是单向流，足够满足状态推送需求，且更简单可靠；WebSocket 的双向能力在这里是过度工程。
- Problem: When a user asks follow-up questions within the same session, sub-queries to the retrieval agent were often identical — fetching the same documents repeatedly at cost and latency.
- Solution: A session-scoped query cache keyed by a hash of the query + filter parameters. Before executing a retrieval node, the graph checks the cache; on a hit, it bypasses the vector DB call entirely.
- Impact: Retrieval latency dropped ~60% on cache hits. Also reduced embedding API costs proportionally.
💡 Tip: 这是 semantic caching 的简化版。可以说："In production at Binance's scale, you'd want full semantic caching — matching similar queries by embedding similarity, which handles ~30% of enterprise query traffic."
- Checkpointing: LangGraph's checkpointer saves state after each node. On failure, I catch the exception, mark the node as errored in state, and return a graceful error message rather than crashing the whole graph.
- Retry logic: For transient failures (rate limits, timeouts), exponential backoff with a max of 3 retries before marking the node as failed.
- Graceful degradation: If the live data agent fails, the graph falls back to retrieval-only mode rather than returning nothing.
- Problem: After retrieval, the graph state only contained raw chunks. Downstream agents had no visibility into why those chunks were retrieved — which source, what relevance score, whether from a news article or a financial filing.
- Solution: I enriched each retrieved chunk with metadata: source document type, recency, relevance score, and retrieval method (dense embedding vs. keyword fallback).
- Benefit 1: The synthesis agent can now down-weight chunks from older filings when news is more recent.
- Benefit 2: The frontend can display "Sources" with confidence indicators — transparency into what the answer is based on.
💡 Tip: 用"provenance"这个词描述 chunk 的来源追踪——在金融 AI 里，能回答"为什么你这么说"几乎和答案本身一样重要。
- Retrieval quality: Built a small test set of questions with known correct answers. Measured recall@5 (were the right documents in the top 5 retrieved?).
- Answer quality: Manually rated a sample of responses on factual accuracy and relevance.
- Latency: Timed end-to-end response time. Retrieval-only: ~1.5s, full multi-agent: ~4–5s.
- Cost tracking: Logged token usage per query to estimate cost per conversation.
- Gap I acknowledge: I didn't implement automated LLM-as-judge evaluation — that would be the natural next step.
- Backend owns all intelligence: LangGraph orchestration, retrieval, LLM calls, caching — nothing intelligent happens in the browser.
- Frontend owns display state only: The TypeScript frontend tracks node statuses for UI rendering but never makes business logic decisions.
- Protocol: Backend streams structured events (node_started, node_completed, final_response) — the frontend maps these to visual states.
- Why this split: Keeps the frontend thin and testable. A CLI or API client can talk to the same backend with no UI coupling.
LLM & RAG 基础
AI Agent 岗位的核心技术面试内容。面试官想确认你真正理解 LLM 的工作原理，而不只是会调 API。
已查看 0 / 10
↓ 按可能性从高到低排序 — 越靠上越重要
- Prompt engineering: Modify the input to steer model behaviour. Zero cost, zero latency overhead. Use when the model already has the knowledge and just needs better instruction. Limit: can't inject dynamic or private data reliably.
- RAG: Retrieve relevant documents at query time and inject into context. Use when answers depend on private, current, or domain-specific data (e.g., ASX filings, Binance market data). No retraining needed. Trade-off: adds retrieval latency.
- Fine-tuning: Update model weights on domain-specific data. Use when you need consistent style, format, or reasoning patterns that can't be achieved with prompts. Trade-off: expensive, slow iteration cycle.
💡 Decision rule: Try prompting first → RAG if knowledge is dynamic/private → fine-tuning only if the above two can't meet quality targets.
Offline (indexing):
- Load and clean documents → chunk into segments → embed each chunk (
text-embedding-3-small) → store vectors + metadata in a vector DB
- Embed the user query → run ANN search in vector DB → optionally re-rank results → inject top-k chunks into LLM prompt → LLM generates grounded response
💡 Key insight: "The most common failure point is chunking strategy. Bad chunks degrade both retrieval precision and generation quality."
定义：LLMs generate plausible-sounding but factually incorrect content because they optimise for fluency, not truth.
Mitigations:
Mitigations:
- RAG grounding: Force the model to answer only from retrieved context, not from parametric memory.
- Citation enforcement: Prompt the model to cite the specific chunk it's drawing from. If it can't cite it, it shouldn't say it.
- Output validation: Use a second LLM call to verify the response is consistent with retrieved documents.
- Uncertainty expression: Ask the model to say "Based on available data, I cannot confirm…" rather than confabulating.
💡 Binance angle: In financial AI, a confabulated stock price could cause real harm. Mention you'd implement strict citation + output validation for any financial use case.
- Traditional DB: Stores structured data, supports exact-match and range queries. Can't find "semantically similar" records.
- Vector DB: Stores high-dimensional float vectors (embeddings). Supports approximate nearest-neighbour (ANN) search — finding vectors semantically close in embedding space.
- How ANN works: Algorithms like HNSW (Hierarchical Navigable Small World) allow sub-linear time lookup across millions of vectors.
- Hybrid search: Production RAG systems combine vector search (semantic recall) + BM25 keyword search (keyword precision).
- What: Prompting the model to reason step-by-step before answering — "Let's think through this step by step…"
- When it helps: Multi-step reasoning (maths, logic, planning), complex instruction-following.
- When it doesn't help: Simple retrieval tasks (adds latency/tokens with no benefit), tasks where speed matters more than accuracy.
- Cost: CoT increases token usage significantly — balance accuracy gain against latency and cost in production.
- Hallucination: Model generates false facts — especially dangerous in financial contexts.
- Tool call failures: LLM selects wrong tool, passes malformed arguments, or misinterprets tool output.
- Infinite loops: Agent keeps calling tools without making progress — needs loop detection and max-step limits.
- Context window overflow: Accumulated tool outputs exceed context limit — need summarisation or pruning.
- Prompt injection: Adversarial content in retrieved documents manipulates agent behaviour.
Two levels: offline evaluation + online monitoring:
- Offline: Golden test set (curated Q&A pairs), retrieval metrics (Recall@k, Precision@k), LLM-as-judge scoring responses on rubrics (accuracy, relevance, conciseness).
- Online: Latency (p50/p95/p99), tool call success rate, user feedback signals (thumbs up/down), cost per conversation, error rates by node type.
- Small chunks (100–300 tokens): Higher retrieval precision. Risk: fragments context, losing surrounding information.
- Large chunks (500–1500 tokens): Preserves more context. Risk: lower precision — dilutes relevance scores with irrelevant text.
- Overlap: Add 10–20% token overlap between consecutive chunks to avoid cutting information across boundaries.
- Practical approach: Start with 512 tokens + 10% overlap, measure retrieval recall on a test set, then tune based on document type.
- What: Instead of caching only exact-match queries, embed the query and cache responses keyed by embedding similarity. If a new query is semantically close to a cached one (cosine similarity > threshold), return the cached response.
- Why valuable: Research shows ~30% of enterprise LLM queries are semantically equivalent paraphrases of previous queries.
- Risk: False positives — semantically similar queries that actually need different answers. Must tune the similarity threshold carefully.
Cost:
- Semantic caching — serve cached responses for semantically equivalent queries
- Model routing — use cheap models (Haiku, Llama) for simple tasks, frontier models only for complex reasoning
- Prompt compression — remove redundant context, shorten system prompts
- Streaming — stream tokens so users perceive faster response
- Parallel tool calls — execute independent tool calls concurrently with
asyncio.gather() - Pre-filter context — only inject the most relevant chunks to keep prompt short
LangGraph & Agent 系统设计
最直接相关的技术问题。大部分偏深，internship 面试可能只浅问前几道，但如果能答出来会非常加分。
已查看 0 / 10
↓ 按可能性从高到低排序 — 越靠上越重要
- LangChain chains: Linear sequence — A → B → C. Good for simple pipelines. Breaks down when you need loops, conditional branching, or multi-agent state.
- LangGraph solves:
- State management: Typed state schema flows through the graph; each node reads and writes state explicitly.
- Conditional routing: Edge conditions decide which node runs next based on current state.
- Persistence: Checkpointer saves state after each node — enables pause, resume, retry.
- Streaming: Native event streaming per node — enables real-time UI updates like your GraphPanel.
ReAct loop:
- Thought: LLM reasons about the current state and what action to take
- Act: LLM selects a tool and generates its arguments
- Observe: Tool executes, result appended to context
- Repeat until LLM decides to return a final answer
- LangGraph: ReAct is the default in
create_react_agent()— a loop node alternating between LLM call and tool execution, with an edge condition that exits when the LLM stops calling tools. - Limit: Linear — one thought-act cycle at a time. Tree-of-Thought explores multiple paths simultaneously for complex problems.
- Checkpointer (within-thread): Saves the full graph state after each node execution within a single conversation thread. Enables resuming a conversation and human-in-the-loop interruptions. Scoped to one session.
- Store (cross-thread): A persistent key-value store shared across multiple conversation threads. Stores long-lived information like user preferences or shared knowledge bases that survive across sessions.
- Analogy: Checkpointer = conversation history within one chat window. Store = a shared notebook all conversations can read and write.
💡 In your project: Your query cache is conceptually similar to Store — it persists retrieved results across the session for reuse.
- Mechanism: LangGraph supports
interrupt_before/interrupt_afteron any node. The graph pauses, serialises its state via checkpointer, and waits for human input. - Flow: Agent plans action → Graph pauses → Human reviews in UI → Human approves/rejects → Graph resumes from checkpoint.
- Use cases at Binance: Before placing a trade recommendation, before sending user notifications, before deleting data — any high-impact irreversible action.
💡 Safety insight: HITL at Binance is partly a regulatory compliance tool — financial AI needs audit trails of human approvals for high-value actions.
- Classify errors first: Retryable (rate limit, timeout, transient network) vs. non-retryable (invalid arguments, permission denied).
- Retry strategy: Exponential backoff with jitter for retryable errors. Max 3 attempts before failing the node.
- Graceful degradation: If a tool fails after retries, fall back to alternative tools or inform the user — never silently return wrong data.
- LangGraph: Wrap tool calls in try/except, update state with error info, use conditional edges to route to fallback nodes.
- What: A TypedDict or Pydantic model defining the shape of data flowing through the graph — e.g.,
messages: list, retrieved_docs: list, query: str, error: str | None. - Why important: Type safety (catches mismatches at construction time), clarity (every node knows what it can read/write), streaming (subscribe to specific fields), checkpointing (determines what gets serialised and restored).
- In multi-agent systems: All agents must agree on the shared state schema — it's the contract between them.
- Supervisor pattern: A central orchestrator LLM decides which specialist agent to call next, collects results, synthesises the final output. Simple to reason about, single point of failure.
- Peer-to-peer (handoff): Agents directly pass control to each other. More parallel, but harder to debug — needs clear handoff contracts.
- In LangGraph: Use sub-graphs for each specialist agent. The supervisor graph has nodes that invoke the sub-graphs as units.
- Key concerns: Shared state schema (contract between agents), cost tracking per agent, conflict resolution, tracing which agent made which decision.
Structure: Requirements → Architecture → Safety → Scale
- Requirements: Natural language queries on crypto markets, news, on-chain data. <5s latency, <$0.01/query cost.
- Architecture: Ingestion pipeline (news feeds, Binance API, on-chain data) → vector DB → LangGraph orchestrator → specialist agent nodes (Retrieval, Live Data, Analysis, Synthesis).
- Caching layer: Semantic cache for repeated queries, TTL cache for live data.
- Safety: HITL for trade-related recommendations, output validation for financial claims, audit logging.
- Scale: Queue-based invocation, read replicas for vector DB, streaming to reduce perceived latency.
- Traces: End-to-end trace per request — every LLM call, tool call, retrieval step with latency breakdown. Tools: LangSmith, OpenTelemetry + Jaeger.
- Metrics: p50/p95/p99 latency per node, token usage, cost per conversation, tool success rate, cache hit rate.
- Logs: Input query (anonymised), node outputs, errors with stack traces, LLM model used.
- LangGraph built-in:
astream_events()emits structured events per node — these are the raw material for your observability pipeline.
- Cache first: Semantic cache check takes ~20ms. On a hit, total response time <50ms.
- Use smaller models: For simple routing nodes, use fast models rather than frontier models.
- Parallel retrieval: Run vector search and keyword search concurrently with
asyncio.gather(). - Pre-filter context: Reduce chunk count passed to the LLM — fewer tokens = faster generation.
- Streaming: Start streaming output as soon as the first token is ready — perceived latency drops significantly.
- Profile first: Use traces to identify which node accounts for most latency before optimising — don't guess.
Web3 & Binance 专项
Binance 面试必定会问你对 crypto 和 Web3 的基础理解——即使是技术岗也不例外。不需要成为专家，展示真诚的好奇心即可。
已查看 0 / 10
↓ 按可能性从高到低排序 — 越靠上越重要
- Core: World's largest crypto exchange by trading volume. Serves 300M+ users in 100+ countries.
- Products: Spot trading, futures/derivatives, staking, Binance Earn (yield products), NFT marketplace, Binance Pay (payments), Binance Academy (education), Trust Wallet.
- BNB Chain: Binance's own blockchain. BNB is the native token — used for trading fee discounts, gas on BNB Chain, and quarterly burn mechanism.
- AI relevance: Binance is actively investing in AI for fraud detection, risk management, trading analytics, and user-facing AI assistants — directly relevant to the Tech Seeds 2026 program.
💡 Show genuine interest: Pick one product you actually tried — "I explored Binance Earn last week to understand the yield products" is worth 10× more than just listing things you Googled.
- Problem: Traditional finance requires a trusted intermediary (bank, clearinghouse) to verify and record transactions — creating centralisation risk, high fees, and exclusion for the unbanked.
- Solution: A blockchain is a distributed ledger replicated across thousands of nodes. No single entity controls it.
- How it works: Transactions are grouped into blocks. Each block contains a cryptographic hash of the previous block, chaining them together. Altering any block invalidates all subsequent blocks — making tampering computationally infeasible.
- Consensus: Nodes agree on the valid chain via PoW or PoS — replacing the need for a trusted central authority.
- Proof of Work (PoW): Miners compete to solve a computationally hard puzzle. Winner adds the next block. Security comes from the energy cost of attacking. Extremely energy-intensive. Used by Bitcoin.
- Proof of Stake (PoS): Validators chosen proportional to crypto staked as collateral. Bad behaviour means stake is "slashed". Security comes from economic loss of attacking. Much more energy-efficient. Used by Ethereum (post-merge).
- Binance relevance: BNB Chain uses Proof of Staked Authority (PoSA) — a PoS variant with a smaller validator set for higher throughput, suitable for high-frequency trading and DApps.
- Definition: Code that runs on a blockchain. Once deployed, it executes automatically when conditions are met — no intermediary needed. Immutable and transparent.
- What they enable: DeFi protocols (lending/trading without a bank), NFTs (digital ownership records), DAOs (token-holder governance), stablecoins.
- Simple example: An escrow smart contract holds funds until both parties confirm delivery. No lawyers, no banks — just code enforcing the agreement.
- Risk: Bugs in smart contracts are permanent and can be exploited. There's no "call customer service" to reverse a bad transaction.
- DeFi: Financial services running on smart contracts — no company owns or operates them. Anyone can use them permissionlessly. Examples: Uniswap (DEX), Aave (lending).
- CeFi (like Binance): A company operates the exchange, holds custody of user funds, handles KYC/AML compliance, and provides customer support.
- Trade-offs: DeFi is permissionless with self-custody but harder UX and smart contract risk. CeFi offers better UX, deeper liquidity, customer support — but requires trust in the company.
- Binance's position: Primarily CeFi, but also operates BNB Chain ecosystem to capture DeFi users.
- Web1: Read-only. Static pages. Users consume content.
- Web2: Read-write. Social platforms (Facebook, YouTube). Users create content but platforms own the data and monetise it. Centralised control.
- Web3: Read-write-own. Users own their data, digital assets, and identities via blockchain. Value accrues to users, not intermediaries.
- Key primitives: Digital wallets (identity), NFTs (digital ownership), tokens (incentive alignment), smart contracts (trustless transactions), DAOs (decentralised governance).
- Trading agents: AI that monitors on-chain data, news sentiment, and technical signals to execute trades autonomously.
- Risk monitoring: Agents scanning DeFi protocols for anomalous behaviour (liquidity drains, unusual large withdrawals) and auto-alerting risk teams.
- Customer support: AI that reads a user's wallet history and answers "why did my transaction fail?" with specific on-chain context.
- Compliance automation: Agents monitoring transactions for AML/CFT patterns and flagging suspicious activity for human review.
- Research synthesis: Your ASX chatbot concept applied to crypto — agents synthesising on-chain data, news, and fundamentals for retail investors.
- What: Crypto assets designed to maintain a stable value, usually pegged 1:1 to USD. Examples: USDT (Tether), USDC, DAI (algorithmic).
- Why important: Safe haven during crypto volatility; DeFi primitive for lending/yield farming/liquidity pools; faster and cheaper cross-border payments than SWIFT.
- Binance angle: BUSD was Binance's own stablecoin until regulatory pressure in 2023 led to its discontinuation — shows that stablecoin regulation is a live, evolving issue.
- Risk: Algorithmic stablecoins (UST/Luna) can collapse — the 2022 Terra crash wiped $40B+.
- Definition: The economic model of a crypto token — how it's created, distributed, used, and what gives it value.
- Key components: Total supply (fixed like Bitcoin's 21M, or inflationary), distribution (team / investors / public sale / ecosystem fund), utility (gas, governance, fee discounts), burn mechanisms that reduce supply over time.
- BNB example: BNB used for trading fee discounts on Binance, gas on BNB Chain. Binance burns BNB quarterly based on trading volume — a deflationary mechanism.
- Why it matters: Good tokenomics aligns incentives so users, developers, and validators all benefit from the network growing.
- Scale: 300M users means extreme query volumes. Latency and cost at that scale are very different challenges from a personal project.
- Real-time data: Crypto markets operate 24/7. AI systems need to ingest live data with very low latency — stale data in a financial context can cause real harm.
- Regulatory compliance: Operating in 100+ countries. AI systems touching financial decisions need audit trails, explainability, and sometimes explicit human approval loops.
- Adversarial users: Some users will actively try to manipulate AI systems — prompt injection, gaming recommendation algorithms, etc.
- Trust and safety: Hallucinated financial information at scale could cause real harm. Quality requirements are much higher than a typical consumer chatbot.