Senior Backend Engineer - AI Platform

Scalifi Ai; Gurugram District; On-site; INR 2,500,000 - 4,000,000; Full time

Benefits offered by this job

Founding-team scope

Direct founder collaboration

Competitive compensation

Job summary

Scalifi Ai in Gurugram is seeking an experienced backend engineer to help build Cognis AI, an AI workspace aggregating multiple models into a single chat layer with memory, observability, and tool execution. You will help own core systems, integrate models, and shape the architecture for roadmap features.

The role requires 3-6 years of backend experience with Python, hands-on LLM tooling, and strong server-side design skills. Join a founding team and ship impactful features quickly.

Qualifications

• 3-6 years of backend engineering with strong Python.
• 2+ years building LLM-powered features used in production.
• Hands-on with provider APIs (OpenAI, Anthropic, Google).
• Experience with agent orchestration and memory/RAG ideas.
• Django/DRF preferred; FastAPI/Flask experience acceptable.
• Multi-provider/model-router systems and tool-call ecosystems.

Responsibilities

• Own base tool end-to-end (e.g., web search with observability).
• Build memory, RAG, and knowledge-base components for the workspace.
• Develop tool-call execution, code interpreters, and sandbox runtimes.
• Collaborate on platform growth and integrations with third-party providers.
• Mentor and interview future backend hires.

Skills

Python

Django

LangGraph

LangChain

REST APIs

PostgreSQL

Redis

WebSockets

OpenAI SDK

Docker

Tools

Django REST Framework (DRF)

LangChain

OpenAI SDK

PostgreSQL

Redis

Docker

Kubernetes

Job description

See what we're building: www.cognis-ai.com (product) | www.scalifiai.com (parent company)

About Cognis Ai

Cognis is an AI workspace that puts 20+ frontier models (GPT, Claude, Gemini, Grok, DeepSeek and more) into a single chat layer - with context that travels across model switches, true branching, chat-layer observability, and an adaptive UI that turns AI replies into working tools instead of walls of text. The platform is live in private beta and being rebuilt for public launch. Backend is Python/Django REST Framework. Built by Scalifi Ai, Gurugram.

We are not competing with the model vendors. We bundle them and build the layers they don't ship: memory, observability, branching, and execution inside the tools work actually happens in.

Work mode: In-office at our Gurugram office (Sector 65) - non-negotiable. Candidates should be in NCR or willing to relocate.

Joining: Immediate to 30-day joiners strongly preferred.

Why this role is different

You'll join the founding backend team, working directly with the founder (who built the current platform). This is not a maintain-the-legacy role and not a research role - it's an ownership role. The architecture decisions on our biggest roadmap features will be yours to make, defend, and ship. You'll also help interview and mentor our next backend hire.

What you'll own

• Base tool layer: web search, image generation, video generation as first-class tools inside the agent loop - each with per-step observability
• Files & media: file and image handling support across providers
• Memory: our persistent, user-editable memory system - pinning, releasing, compaction, and per-item token accounting
• RAG & knowledge bases: chunking, retrieval, reranking, and retrieval-quality evaluation, wired into the workspace
• Execution environments (upcoming): code interpreters for context-efficient, parallel tool calls; sandboxed runtimes and a workspace filesystem for agent file operations
• Product analytics: deep, Cognis-specific analytics (beyond our generic platform layer)
• Platform growth work (shared, especially early on): adding new LLM providers and models - message serialization, streaming, tool-call handling - and new third-party integrations on our integrations layer, where OAuth, tool search, and execution are already built. You'll help turn these into runbooks our next hire executes.

What you'll ship in your first 90 days

• One base tool end-to-end (e.g., web search with full step-level observability)
• The first version of the memory/compaction architecture, co-designed with the founder

Must-haves

• 3-6 years of backend engineering with strong Python
• 2+ years building LLM-powered features that real users used in production - not tutorials, not POCs
• Hands-on with provider APIs (OpenAI, Anthropic, Google) - you can describe what a tool-call delta looks like in a raw streaming response
• Agent orchestration in production: LangGraph/LangChain, or an equivalent system you built yourself on raw SDKs
• Context management: message history design, summarization/compaction trade-offs, token economics, prompt caching
• RAG beyond hello-world: chunking strategy, hybrid retrieval, reranking, and how you evaluated retrieval quality
• Django/DRF preferred - deep FastAPI/Flask experience with willingness to work in DRF is fine
• Multi-provider or model-router systems; provider failover
• Tool-calling ecosystems and integration platforms (e.g., MCP)
• Sandboxed code execution - containers, microVMs, or code-interpreter style tooling
• Vector databases (pgvector, Qdrant, Pinecone) and embedding pipelines
• Eval tooling and LLM observability
• Early-stage startup experience or meaningful open-source work

Stack

Python | Django REST Framework | LangGraph + LangChain (agent orchestration) | PostgreSQL | Redis | WebSockets/SSE | OpenAI/Anthropic/Google SDKs | a unified third-party integrations layer - plus whatever you make the case for.

What we offer

• Founding-team scope with direct, daily work alongside the founder - zero bureaucracy, weekly shipping
• Your fingerprints on every major system of an AI product at exactly the moment the category is being defined
• Competitive compensation, reviewed as the company grows