Founding Engineer - Olympiz

Meraki Labs; Bengaluru; On-site; INR 2,500,000 - 4,000,000; Full time

Job summary

Meraki Labs, Bangalore-based AI-driven EdTech startup, seeks a senior software engineer to own end-to-end systems for autonomous agents in production.

You will work on memory architecture, model orchestration, latency optimization, and operator tooling, with live debugging and benchmarking across models, maintaining reliability in a fast-moving environment.

Qualifications

• 5+ years in software engineering with production ownership.
• Proven experience with LLM-based native apps.
• Proficient in Python; comfortable with TypeScript/Node.
• Strong understanding of distributed/stateful systems.
• Experience with testing before features and evidence-based decisions.

Responsibilities

• Own systems enabling trustworthy autonomous agents in production.
• Enhance memory and scheduling reliability.
• Develop agent tooling, live debugging, and model benchmarking.
• Collaborate in a small, high-trust startup environment.

Skills

Software engineering

LLM integration

Python

TypeScript/Node

Distributed systems

Production ownership

Testing discipline

Memory management

Job description

About Us

An AI-first EdTech company building next-generation learning solutions for JEE, NEET, Olympiads, and school-level competitive preparation. A platform where teachers and students connect for live classes offline and online.

Target Audience: Students preparing for JEE, NEET, Olympiads, and school-level competitive exams.

Core Framework: Operating at the intersection of education, live teaching sessions, AI, product, content, student mentoring, testing, analytics, and growth.

The Goal: To create a unified platform that makes high-quality academic guidance significantly more personalized, scalable, and outcome-driven

The role

Full-time

• Bangalore

You’ll own the systems that make an autonomous agent trustworthy in production. This is not just prompt engineering, and it’s not model training - it’s that and all the engineering layers in between: model steering, memory architecture, orchestration design, latency optimization, deterministic vs non-deterministic systems tradeoff, deployment, and operator tooling.

Concretely, the kind of work you’d have done here last week would include enhancing agent memory systems, runtime and scheduling reliability and predictability, adding new capability and tools to deployed agents, operator tools, live system debugging and benchmarking various models for price, latency and quality. And that is just last week. We are a small nimble startup rapidly working to address customer needs in this growing space, so things change rapidly.

What we're looking for

• 5+ years of software engineering, with real production ownership of distributed or stateful systems - you've been paged for something you built and made it not happen again.
• Strong understanding of LLM based native app building, combining classic and model driven applications to get the best of both. You've built on LLMs beyond demos: agent frameworks, tool use, context management, eval fixtures, and you know why "it worked in the transcript" isn't evidence.
• Python and shell in production settings; comfortable in TypeScript/Node. You write boring, testable code and prefer the standard library to a new dependency.
• Systems taste: append-only logs, idempotent reconciliation, fold-the-events state machines, and read-only debugging surfaces feel like home.
• Evidence discipline: tests before features, claims backed by quoted observations, decisions written down.

Nice to have

• Experience running the combination of multi-tenant and single-tenant / on-prem-style fleets with ability to handle per-customer isolation, upgrade paths, migration compatibility in both setups.
• Security instincts for products that touch highly sensitive data and systems, including things like executives' email, calendars, and messages: least privilege, loopback-only services, secrets that never hit a log.
• You already orchestrate AI coding agents in your own workflow and have opinions about where they break.

How we work

Small team, high trust, written decisions. Designs get adversarial review before code; PRs get automated review driven to zero open findings; features aren't done until verified on a live system. AI agents do a large share of the implementation, your leverage is judgment: framing the problem, freezing the right design, and knowing when the machine is wrong.