
Dipesh Chaulagain
Team LeadSets sprint priorities, unblocks technical decisions, and keeps delivery aligned with runtime quality and customer commitments.
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.
A strong demo is not the same as software your team can run every day.
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.
We handle security, approvals, and logs — so your team can move fast on the product your users actually see.
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.
01Developer experience
Typed APIs, local dev parity, and CI/CD deploys — ship on your team's cadence.
02Policy & governance
Approvals, audit trails, and access rules your risk team can prove.
03Orchestration & execution
Agents that plan, use tools, and hand off to humans when needed.
Your production system
Observable agents — same guarantees on every build
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.

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

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

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

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

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

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

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

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

Shapes editorial, case studies, and engagement narratives so complex runtime concepts read clearly for prospects and partners.
Designs interfaces and motion systems that make the software we ship feel precise, legible, and alive across web and product surfaces.
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.
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.
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.
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.
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.
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.
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.
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.
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.