Build Antibrittle Agents With Us

https://jobs.gem.com/southbridge-ai/am9icG9zdDoargQV0uUom0F1c9EN2wkd

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.

Why Context Comes First

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.

How We Think

• 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.

What You’ll Work On

• 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, ship it to real users, and share at least one internal note or open-source artefact. We’ll bring you into customer deployments early so you see the stakes up close.

What We’ve Already Built

• 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.

Backend Engineer

Full-time · Founding Team

https://jobs.gem.com/southbridge-ai/am9icG9zdDoargQV0uUom0F1c9EN2wkd

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.

What You’ll Build

• 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.

Stack & Tooling

• 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.

How We Work Together

• 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.

What You Bring

• 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.

Signals We Love

• 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.

Why This Work Matters

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.

How to Start the Conversation

1. Please share your Portfolio by sharing a short Loom/Tella/Video platform of your choice walk-through. We work globally so remote async communication skills are important.
2. Share what you've shipped – Links, repos, notes, or whatever you are proud of. We value artifacts over résumés and love the context behind them.
3. Meet one of the team – 30-minute conversation to see if the work resonates and answer your initial questions.
4. Conversation with Hrishi – 45 minutes trading stories with our CEO about approaches, trade-offs, and how you think about agents; bring the questions you want answered.
5. Take-home challenge – Work through a real problem (e.g., extending Tadpole's state machine or redesigning a streaming ingestion loop). Focused and realistic, no trick questions.
6. Technical deep dive – Review your solution with Hrishi. Code and architecture together, no trivia, plenty of space for clarifications.
7. Your questions for us – Dedicated time for you to interview us on anything that matters to your decision.
8. 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.
9. 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.

Only applications submitted through https://jobs.gem.com/southbridge-ai will be accepted. We will not be responding to applications on LinkedIn.