[01] ABOUT / STUDIO

A software studio building custom agentic systems — production-grade from day one.

Agents need receipts: what ran, who approved it, on what data.

We design and build the agentic software you ship — on our own secure runtime, with visibility, control, and governance wired in from the first commit.

Schematic console: health, agents, governance.

[02] THESIS

Why we built Novelty Lab

A strong demo is not the same as software your team can run every day.

Trust over timeConceptual
Gray: great at first, then fades. Blue: trust that keeps growing.

Most AI agent tools shine in week one. Real teams need them to still work in month six — when security asks questions, models change, and traffic grows.

  • Most tools today

    • Look great in a sales demo
    • Hard to explain to security or legal
    • Get shakier as more people use them
  • Novelty Lab

    • Built for daily use, not just pilots
    • Clear log of what ran and who approved it
    • More dependable the longer you run it

We handle security, approvals, and logs — so your team can move fast on the product your users actually see.

[03] WHAT WE SHIP

Custom systems on a hardened runtime

Every system we build for you rests on the same three foundations — build, govern, and run. Not add-ons you negotiate later.

One stack your engineers extend, your auditors trace, and your operators run — so you inherit the boring guarantees and we focus on what is custom to you.

Three layers stack into your production system: developer experience, policy and governance, and orchestration.
  1. 01Developer experience

    Typed APIs, local dev parity, and CI/CD deploys — ship on your team's cadence.

  2. 02Policy & governance

    Approvals, audit trails, and access rules your risk team can prove.

  3. 03Orchestration & execution

    Agents that plan, use tools, and hand off to humans when needed.

Your production system

Observable agents — same guarantees on every build

[04] TEAM

The people behind Novelty Lab

Roles & focus

A compact group across engineering, product, design, sales, content, finance, and operations — each with a clear lane, so customers always know who owns what when we ship together.

  • Dipesh Chaulagain, Team Lead

    Dipesh Chaulagain

    Team Lead

    Sets sprint priorities, unblocks technical decisions, and keeps delivery aligned with runtime quality and customer commitments.

  • Niraj Pahadi, Software Engineer

    Niraj Pahadi

    Software Engineer

    Ships core services and integrations — APIs, reliability paths, and code reviews that keep production boring in the best way.

  • Rupesh Chaulagain, AI Engineer

    Rupesh Chaulagain

    AI Engineer

    Owns agent workflows, model integrations, and evaluation loops so intelligent behavior stays observable and governable.

  • Kshitij Dhamala, Product Engineer

    Kshitij Dhamala

    Product Engineer

    Turns roadmap intent into concrete UX and measurable outcomes — specs, iterations, and tight feedback with design partners.

  • Sargam Ghimire, DevOps Engineer

    Sargam Ghimire

    DevOps Engineer

    Owns infrastructure, CI/CD, and cloud reliability so releases stay fast and production stays stable.

  • Milan Poudel, Finance Manager

    Milan Poudel

    Finance Manager

    Runs budgeting, forecasting, and reporting so engineering and GTM moves stay grounded in clear numbers and runway.

  • Reemesh KC, Operation Manager

    Reemesh KC

    Operation Manager

    Keeps internal processes, vendor coordination, and day-to-day execution smooth — fewer surprises, clearer handoffs.

  • Samip Chaulagain, Sales & Customer

    Samip Chaulagain

    Sales & Customer

    Leads discovery, customer relationships, and handoffs from first call through delivery — so what we promise matches what ships.

  • Sujab Banjara, Content Manager

    Sujab Banjara

    Content Manager

    Shapes editorial, case studies, and engagement narratives so complex runtime concepts read clearly for prospects and partners.

  • Anish Kayastha, UX & Motion Designer

    Anish Kayastha

    UX & Motion Designer

    Designs interfaces and motion systems that make the software we ship feel precise, legible, and alive across web and product surfaces.

[05] HOW WE PARTNER

We ship with you — not at you

Design partnerships

Early in a rollout we embed with your platform and security leads. We map data flows, tool boundaries, and approval paths so the first production agent is boring — not heroic.

Proof over promises

We rehearse failure: replay tools, inject policy changes mid-flight, and walk auditors through trace exports. If we cannot show it in your environment, we do not claim it in a slide.

Long arc support

Agents evolve weekly. We stay close through model upgrades, new regulations, and org changes — with clear ownership so you are never stuck between vendors pointing fingers.

[06] JOURNEY

From first engagement to trusted runtime

Genesis

A studio for production-grade agents

We started as a software studio building agentic systems for teams in ecommerce, learning, and security operations — clients who could not afford another chat wrapper. Off-the-shelf foundations broke the moment real traffic hit, so we kept rebuilding the parts everyone needed.

Hardening

Our own runtime, under every build

We invested years in execution semantics, policy composition, latency envelopes, and deterministic replay so the systems we ship can sit next to payments and PII without improvising. That work became our runtime — the foundation every engagement now ships on.

Scale

Multi-tenant governance at speed

As client systems grew, engagements needed per-tenant isolation, federated identity, and audit exports that matched existing GRC stacks. We made those primitives part of the runtime, so the same foundation carries a single squad or a global program with thousands of agents.

Today

Custom agentic software, audit-ready on day one

Novelty Lab is where teams come when intent has to become shipped software — visibility, security, control, compliance, and governance treated as physics, not marketing adjectives. We are still small, senior, and obsessed with the hard edges.

[07] TRUST & ASSURANCE

Programs your security team already asks for

We maintain a public roadmap for certifications, share penetration-test summaries where policy allows, and document runtime behavior alongside the systems we build — not just UI tweaks. Engagements include shared Slack or Teams channels with the engineers who actually merge code.

  • SOC 2
  • ISO 27001
  • HIPAA
  • GDPR
[8] TEAM & CULTURE

Distributed, senior, and impatient with theater

Alongside our founders, a small group of engineers and field leads ships client engagements every week — and hardens the runtime underneath as we go. We optimize for depth over headcount: fewer meetings, longer uninterrupted blocks, and writing that survives a skeptical security review.

If that sounds like your kind of environment, we would love to meet you. We hire slowly and support people who take real ownership of outcomes.