As a Backend Engineer, you'll develop agentic orchestration, improve context-preserving retrieval and ensure long-horizon reliability for AI systems. Collaboration and open-source contributions are key aspects of the role.
Build Antibrittle Agents With Us
Why Context Comes First
How We Think
What You’ll Work On
What We’ve Already Built
How We Work
Backend Engineer
What You’ll Build
Stack & Tooling
How We Work Together
What You Bring
Signals We Love
Why This Work Matters
How to Start the Conversation
Any expression of intelligence is a transformation of data.
At Southbridge, we make that transformation reliable. We are a team of engineers and researchers building the first agentic data layer—systems where long-horizon AI agents can ingest, structure, and retrieve enterprise data without shattering. We call these antibrittle agents: orchestration stacks that get stronger the longer they run, because we design them with room to adapt and receipts to keep us honest.
AI models keep getting sharper, but most still feel like brilliant interns who can’t find anything. The bottleneck is context. Vector stores slice documents into fragments. ETL scripts drift out of date faster than they’re written. Enterprises teach new team members the shape of their data over six-year journeys—then watch the schema change.
We build for the people who live that frustration. Our walking-RAG pipelines read 1,000-page manuals, engineering diagrams, and telemetry streams without losing their relationships. Tadpole, our long-horizon runner, keeps Claude-class models productive for hours by trenching state, resetting cleanly, and capturing receipts with every step. The goal: agents you can trust at the bottom of the stack.
- Context, not chunks – Every table remembers its document; every value knows its column. We keep structure intact from ingestion to retrieval.
- Agents, not brittle pipelines – Static workflows crack when reality shifts. Our agents reason about ingestion, transformation, and retrieval in real time and adapt when schemas move.
- Receipts above claims – We care about “nines of accountability.” Costs, decisions, failures, recoveries—everything is inspectable, everyone holds the same bar.
- Building blocks, not black boxes – We publish what we can under Apache 2.0 because shared primitives help us move faster and keep us honest. Offmute, diagen, wishful-search, tip20, next-cursor-base - they all started as tools we needed first.
- 180s are expected – Models evolve weekly. When the data asks us to change direction, we do it together.
- Agentic orchestration – Extend Tadpole’s execution architecture so agents coordinate ingestion, schema inference, and retrieval with accountable state. You’ll do this alongside the people who sketched the first trenches.
- Context-preserving retrieval – Move past chunks. Build walking pipelines that understand nested JSON, spreadsheets, and industrial PDFs end-to-end, with teammates who have scars from legacy ETL.
- Human-first interfaces – Surface agent decisions with clarity: live traces, streaming diffs, receipts that help partners trust what they see, and that help us debug together.
- Reusable primitives – Extract the tools we need into open-source micropackages—utilities that the wider AI community wants to fork tomorrow, and that we’re proud to support.
Your first few months are collaborative by design. You’ll co-own a meaningful slice of Tadpole (backend) or southbridge.ai (frontend) with another teammate, ship it to real users, and share at least one internal note or open-source artifact. We’ll bring you into customer deployments early so you see the stakes up close, with the rest of us on the call.
- Antibrittle agent runners that keep Claude, Gemini, and Kimi K2 productive for multi-hour tasks.
- Walking RAG systems that read technical manuals, diagrams, and mixed-format archives for Fortune 150 teams.
- Open-source tooling with real adoption—Lumentis, offmute, diagen, tip20, wishful-search, and more.
- Evaluation harnesses that track new model releases the week they land, so we can pivot with evidence.
- Tiny, senior, hands-on – Everyone codes, reviews, and joins customer calls. We break problems down together.
- Structured freedom – Tight trenches, wide exploration. We isolate execution, reset state often, and let agents roam inside deliberate boundaries so we can learn safely.
- Shared tooling – TypeScript end-to-end, Bun + Hono + Drizzle for services, Postgres / DuckDB / ClickHouse for data, Next.js and Tailwind for interfaces. Day to day we live inside Claude Code, Cline, Gemini CLI, Cursor, v0, and a healthy bench of open-source helpers.
- Learning loops – Weekly show-and-tells, shared eval reviews, and internal notes that often graduate into public posts when the timing’s right.
- Open source as leverage – When value exchange is lopsided, we share the work. Community feedback keeps us curious and careful.
Full-time · Founding Team
We’re building Tadpole—the execution engine that keeps long-horizon agents steady for hours instead of minutes.
As a backend engineer at Southbridge, you’ll design the trenches, receipts, and orchestration logic that let Claude-, Gemini-, and Kimi-class systems ingest enterprise data, reason across trillions of schemas, and recover gracefully when reality shifts. You’ll be shoulder to shoulder with teammates who have lived those shifts already and are eager to share the patterns, runbooks, and cautionary tales.
- Agentic orchestration – Extend Tadpole’s TypeScript core so multiple agents can coordinate ingestion, transformation, and retrieval while remaining observable and interruptible. You’ll decide, with the folks who sketched the first trench diagrams, what “observable” should mean next.
- Context-preserving ingestion – Stream nested JSON, spreadsheets, industrial PDFs, and telemetry at gigabit speeds without losing structure. Sub-millisecond decisions matter here, and you’ll have teammates profiling and tuning alongside you.
- Long-horizon reliability – Engineer checkpointing, rollback, and receipt systems so every action is traceable. When things wobble, we want to know where and why, and you’ll help set that shared discipline.
- Reusable primitives – Extract the tools we need into OSS micropackages under Apache 2.0—utilities the wider community wants to fork tomorrow and that we’re proud to maintain together.
- Production deployments – Pair with customers in finance, logistics, and infrastructure to harden the system where it meets messy real-world data. Every deployment is a team sport.
During your first few months, you’ll co-own a slice of Tadpole’s execution state or tooling APIs with another engineer, ship it to production, and share at least one internal note or open library that survives external scrutiny. We’ll bring you along for a customer deployment early—expect the rest of us on the call, comparing notes in real time.
- Runtime – TypeScript everywhere with Bun, Hono services, Drizzle migrations, typed event streams.
- Data – Postgres as ground truth, DuckDB and ClickHouse for analytical workloads, Redis for fast coordination.
- AI interfaces – Direct connections to Claude, Gemini, GPT, and open checkpoints routed through our evaluation harnesses.
- Execution fabric – WebSockets, durable queues, stateful workers, and selective serverless when latency wins.
- Daily tools – Claude Code, Cline, Gemini CLI, a healthy bench of open-source helpers, plus Cursor, v0, and next-cursor-base when they keep the trenches tidy.
- We break problems down side by side – Interfaces, isolation, and deleted accidental complexity are shared habits, not solo hero moves.
- Receipts come above claims – “Nines of accountability” beats “nines of availability.” We gather evidence before we celebrate, and everyone keeps the same bar.
- Ship with trails – Token costs, tool invocations, diffs, failure paths—every system we touch leaves an audit trail so agents stay trustworthy.
- Stay wide – Model capabilities change weekly. We prototype with new releases, run evals together, and aren’t precious about switching approaches when the data nudges us elsewhere.
- Feedback loops are short – You’ll pair with Hrishi and the rest of the founding team. Customer feedback lands in our laps in real time, and we process it together.
- Senior-level TypeScript engineer who treats the type system as a design tool.
- Experience with distributed systems, data pipelines, or agent tooling where correctness and latency both mattered.
- Comfort moving from proof-of-concept to production—instrumentation, alerting, operational playbooks included.
- Ability to reason about the trade-offs between determinism and exploration in AI-driven workflows.
- Builder of real things—startups, OSS packages, internal platforms—with receipts you can point us to.
- You’ve made or salvaged an LLM agent that ran longer than an hour without babysitting, and you kept the logs.
- You enjoy wiring evaluation harnesses; metrics like pass@k, coverage, and hallucination detection feel familiar.
- You’ve navigated Fortune-100-style compliance or audit constraints and still shipped advanced tooling.
- You have opinions about schema-on-write vs. schema-on-read, and you’re happy to share the scars.
You’re building new primitives. The orchestrators you shape become the infrastructure others lean on when they want AI systems that actually understand their data. We work on real problems—1000-page technical manuals, multi-modal telemetry, cross-border compliance datasets—where “pretty good” isn’t enough. You’ll learn at the frontier; we test major model releases as they land, implement papers while the ink dries, and swap notes with the community through our open-source work.
- Share what you've shipped – Links, repos, notes, or a short Loom/Tella video. We value artifacts over résumés and love the context behind them.
- ⭐️ If you would like to skip the Take-Home Challenge Phase (Below) than please walk us through one of your projects in the video you submit, share your screen and dig into the planning, codebase and decisions that you went through to help us understand how you approach engineering.
- Take-home challenge – If you don't submit a clear example of your work then we will need you to work through a real problem (e.g., extending Tadpole's state machine or redesigning a streaming ingestion loop). Focused and realistic, no trick questions.
- Meet one of the team – 30-minute conversation to see if our work resonates and to find out more about you.
- Technical deep dive – 45 minutes Review your solution with Hrishi. Code and architecture together, no trivia, plenty of space for clarifications.
- Your questions for us – Dedicated time for you to interview us on anything that matters to your decision.
- Pairing session – Co-debug or extend a live micropackage with the team. We share the brief beforehand and treat the session as a two-way fit check.
- Offer & onboarding plan – We tailor scope, compensation, and relocation support to what lets you do your best work, and we map out how your first months will feel.
Bring logs or a story about the longest agent run you’ve tamed—we’re always happy to swap notes.
If none of these fit but you’re already building with frontier models, reach out at [email protected]. Show us something you shipped, and tell us where you want the agentic future to go.
We’re always interested in the people who make agents a little less brittle and a lot more useful.
Top Skills
Bun
Clickhouse
Drizzle
Duckdb
Hono
Next.Js
Postgres
Redis
Tailwind
Typescript
Websockets
Similar Jobs
Cloud • Security • Software • Cybersecurity • Automation
As a Staff Backend Engineer, you will design and manage a graph data service, ensuring reliability and performance while collaborating across teams and improving system architecture.
Top Skills:
Ai ToolsClickhouseGoNatsRubyRustTypescriptVue
Cloud • Security • Software • Cybersecurity • Automation
As an Intermediate Backend Engineer, you will design and maintain a Go-based instrumentation service, ensuring data quality and aiding product teams in feature instrumentation.
Top Skills:
GoGrpcRestRuby On Rails
Cloud • Security • Software • Cybersecurity • Automation
As a Backend Engineer, you will design and maintain a Go-based instrumentation service, manage data integrity for usage billing, and support teams in instrumenting features effectively.
Top Skills:
GoGrpcRestRuby On Rails
What you need to know about the Chennai Tech Scene
To locals, it's no secret that South India is leading the charge in big data infrastructure. While the environmental impact of data centers has long been a concern, emerging hubs like Chennai are favored by companies seeking ready access to renewable energy resources, which provide more sustainable and cost-effective solutions. As a result, Chennai, along with neighboring Bengaluru and Hyderabad, is poised for significant growth, with a projected 65 percent increase in data center capacity over the next decade.
