Website:
bridge-it.ai
Job details:
Senior AI Engineer — Bridge-it AI Team
Location: Remote
Experience: 3–5 years in industry
Team: AI Platform (Copilot)
About Bridge-it
Bridge-it is an early-stage EdTech company building a career-readiness platform for K-12 students, counselors, and districts. Students explore careers, colleges, and non-college pathways; build multi-year plans; and get guidance from an AI Copilot that is grounded in their own plans, school data, and a curated knowledge base. Counselors use the same platform to supervise, nudge, and intervene at scale.
The AI Copilot is the heart of the product — a production LangGraph-based agentic system serving real students, where being
right matters more than being fluent. We hold ourselves to strict grounding, safety, and tenant-isolation standards, and we measure everything.
About The Role
You will join a small AI team that owns the Copilot end to end: the agentic orchestration graph, retrieval and grounding, safety guardrails, response contracts with the frontend, and the evaluation platform that keeps it honest. We are mid-flight on an ambitious redesign — collapsing multiple experimental graph variants into a single workflow-first architecture with typed claim verification, constitutional rules, and per-turn decision records — and you would step directly into that work.
This is a senior IC role with a visible leadership runway. Beyond writing excellent code, we expect you to analyze ambiguous product requirements, turn them into well-scoped technical specs and tickets, distribute work across the team, and communicate trade-offs clearly to product and leadership. For the right person, this role grows into a team-lead position.
What You'll Do
- Design, build, and operate agentic LLM workflows in LangGraph — routing, planning, parallel retrieval, tool execution, verification, and streaming — serving live student and counselor traffic over WebSockets.
- Own RAG quality: multi-source retrieval across vector stores (Milvus, pgvector), a knowledge graph (Neo4j), and structured platform data; chunking strategy; reranking; and grounded generation with typed claims and evidence citation.
- Enforce safety and trust: input/output guardrails, constitutional rules, faithfulness verification, abstain/escalate behavior, and strict multi-tenant data isolation.
- Build and extend our evaluation platform: online LLM-as-judge evaluators, offline regression suites on curated datasets (LangSmith), latency baselines, and A/B experimentation (PostHog feature flags).
- Drive latency and cost optimization: model selection across providers (OpenAI, Gemini, open-weight models via OpenRouter), prompt and context engineering, selective retrieval, caching, and streaming intermediate responses.
- Instrument and debug production behavior with LangSmith tracing, OpenTelemetry, New Relic, and Sentry; treat live-QA findings as first-class inputs to design.
- Partner with backend (Django/Postgres), frontend (Next.js), and product teams on response envelopes, interaction contracts, and rollout plans.
- Lead by doing: break epics into staged implementation plans with acceptance criteria, sequence work across engineers, review code, and mentor teammates.
What We're Looking For (required)
- 3–5 years of professional software engineering experience, with at least 1–2 years building LLM-powered products in production (not just prototypes or notebooks).
- Strong Python engineering fundamentals — typing, testing, async, service design.
- Strong grasp of agentic architecture patterns — supervisor/executor splits, planner–retriever–verifier pipelines, tool/capability registries, routing and fallback tiers — and sound judgment about when a workflow should be deterministic versus agentic.
- Hands-on experience with agent orchestration frameworks (LangGraph strongly preferred; LangChain, or comparable state-machine/agent frameworks acceptable) including multi-step graphs, tool calling, and streaming.
- Context engineering / harness engineering: deliberate construction of what the model sees each turn — context budgets, retrieval selection, system-prompt and tool-schema design, structured state passed between nodes — and the harness discipline (contracts, guards, fallbacks) that makes model behavior predictable.
- Experience designing and optimizing agent memory: short-term conversation state (windowing, summarization/compaction, token-budget management) and long-term memory (user profiles, episodic stores, rollups) with sensible retrieval and staleness policies.
- Deep practical knowledge of RAG systems: embedding models, vector databases (Milvus/Zilliz, pgvector, or similar), hybrid retrieval, rerankers (e.g., Cohere), chunking and knowledge-base design.
- Proven experience building and operating LLM evaluation systems: online evaluators (LLM-as-judge) on live traffic, offline golden datasets and regression suites, faithfulness/hallucination and groundedness metrics, A/B experiment design — and the discipline to gate releases on eval results.
- Hands-on AI observability: end-to-end trace instrumentation of agent runs (LangSmith, OpenTelemetry GenAI conventions, or similar), per-node latency/token/cost tracking, trajectory analysis, drift and quality-regression monitoring, and turning production traces into eval datasets and fixes.
- Experience shipping structured outputs (JSON contracts, schema-validated responses) as the interface between models and product surfaces.
- Comfort with cloud infrastructure (GCP preferred: Cloud Run, Pub/Sub, GCS, BigQuery).
- Excellent communication and interpersonal skills: you can explain a retrieval-quality trade-off to a product manager, write a spec another engineer can execute, and disagree constructively.
- Demonstrated ability in requirement analysis and task decomposition — turning fuzzy asks into staged, dependency-ordered work — and willingness to step up into team-lead responsibilities.
Desirable
- Experience at an early-stage startup — comfort with ambiguity, wearing multiple hats, and shipping under constraints.
- Model Context Protocol (MCP): working knowledge of the spec and hands-on experience building or integrating MCP servers/clients to expose tools and data to agents.
- Knowledge graphs (Neo4j/Cypher) in retrieval or recommendation contexts.
- Durable workflow engines (Temporal) and event-driven architectures (Pub/Sub).
- Multi-tenant SaaS security models (row-level tenancy, FERPA/COPPA-adjacent compliance awareness).
- EdTech or other regulated/high-trust consumer domains.
Nice to have
- AI infrastructure: model serving, GPU inference, gateway/router layers, and cost/latency-aware routing across providers.
- SLMs and self-hosted LLMs: deploying and operating small language models or open-weight LLMs (vLLM, TGI, Ollama, or similar), quantization, fine-tuning/distillation for task-specific workloads, and knowing when a small model beats an API call.
- Traditional ML: classification, ranking, embedding fine-tuning; scikit-learn/PyTorch.
- Recommender systems: candidate generation + ranking pipelines, personalization.
- Forecasting and data analytics: time-series methods, cohort analysis, product analytics.
- Big data processing/streaming: BigQuery at scale, Spark/Flink/Kafka or Pub/Sub streaming pipelines, dbt-style transformation workflows.
Our stack (so you know what you're signing up for)
Python
- LangGraph/LangChain
- OpenAI + Gemini + open-weight models (OpenRouter)
- Milvus/Zilliz
- pgvector
- Neo4j
- Cohere reranking
- LangSmith
- Django + PostgreSQL
- Temporal
- GCP (Cloud Run, Pub/Sub, GCS, BigQuery)
- PostHog
- OpenTelemetry/New Relic/Sentry
- Next.js frontend over a WebSocket streaming protocol.
Bridge-it is an equal opportunity employer. We welcome applicants of all backgrounds and are committed to an inclusive, respectful remote-first workplace.
Click on Apply to know more.