NDZ LABS · INDEPENDENT R&D STUDIO

Designing AI systems that make humans better at complex work

NDZ Labs is an independent AI R&D lab exploring how agentic systems can augment human work from product development and research to analysis and decision-making.

We build experiments to understand what AI should do, what humans should keep doing, and what kind of system makes the collaboration work

From product definition to implementation, testing, recovery and release — with humans making the decisions that matter.

02 — The Core Idea

AI doesn't have to make humans unnecessary to make them more productive.

We believe the most valuable AI systems are not necessarily the ones that replace the most human work, but the ones that remove the mechanical parts of complex workflows and give people more room for creativity, judgment, strategy and decision-making.

The objective is not to make humans work less, it's to help them work better.

By delegating execution to agentic systems, humans can spend more of their limited attention on the parts of the process where their involvement matters most.

AI handles more of the execution. Humans retain more of the agency.

03 — The Question

AI can already execute many parts of complex workflows.

The harder question is what we should ask it to do

  • How much autonomy should an agent have?
  • When is a specialized team better than a single agent?
  • When does automation actually improve human work?
  • And what happens when execution becomes abundant?

NDZ Labs explores those questions by building real systems and testing them in real workflows.

The goal isn't to replace the human. It's to increase what the human can think, create and accomplish.

04 — Systems we've built

Different questions require different architectures.

The NDZ Development System is an agentic development environment originally built to accelerate internal product development.

It evolved into a general-purpose system for coordinating product definition, design, implementation, testing, debugging and documentation across an entire software lifecycle.

01

Define

Translate the problem into explicit requirements.

  • Product requirements
  • Roadmap
  • Business rules
  • Acceptance criteria
  • Product documentation
02

Contract

Create a structured interface between roles.

  • Requirements
  • Boundaries
  • Dependencies
  • Expected outputs
  • Validation criteria
03

Build

Allow an agent to execute within those boundaries.

  • Product
  • Design
  • Development
  • Testing
04

Verify

Evaluate the result against explicit criteria.

  • Tests
  • Assertions
  • Validation
  • Regression checks
05

Recover

Handle failure without restarting the entire process.

  • Diagnosis
  • Correction
  • Test history
  • Recovery
  • Rollback
06

Evolve

Feed what was learned back into the system.

  • Changelog
  • Versions
  • Change requests
  • Business requirements
07

Produce a usable outcome.

A functional MVP emerges together with the documentation and history required to understand how it was built and how it evolved.

This is not a universal architecture. It's one of the systems we've been using to explore agentic workflows.

05 — The Agentic Architecture

There is no single architecture for agentic systems.

The right structure depends on the work being delegated, the level of autonomy required and where human judgment needs to remain in the loop.

NDZ Labs experiments with different architectural patterns to understand what works, where they fail and when one approach is preferable to another.

Declarative systems

Explicit responsibilities, contracts and workflows define how agents interact and what each stage is expected to produce.

Skills-based agents

A capable agent can acquire specialized behaviors through skills without requiring an independent agent for every responsibility.

Agentic teams

Multiple specialized agents can reproduce organizational roles such as Product Management, Design, Development and QA.

Human-led systems

The human remains an explicit component of the architecture, defining direction, making critical decisions and intervening where autonomy stops being useful.

The architecture is part of the experiment

06 — The Agnostic Layer

The intelligence can change. The system remains.

NDZ Labs systems are designed to remain independent from the environment in which they operate.
Models, providers, development environments, tools and infrastructure can change without redefining the system itself.
This separation allows us to move experiments across different environments without rebuilding the architecture around a specific vendor or workflow.
More importantly, it keeps the research focused on the system and the problem it is designed to solve, rather than on the particular technology used to run it.

LLM

LLM agnostic

The development workflow is not built around a specific model provider.

Different models can execute different parts of the system without redefining the product process.

IDE

IDE agnostic

The system does not depend on a particular development environment.

The orchestration layer lives above the tools used to write the code.

LANG

Language agnostic

The contracts describe what the system needs to achieve, rather than prescribing a specific programming language.

The implementation stack can change without changing the underlying development methodology.

Product intent
Contracts
Agent orchestration
Any model · Any IDE · Any language
Validated software

The implementation is replaceable. The system of coordination is not.

07 — Experiments

Every NDZ Labs project starts with a question

01

AerOS Personal

The first complete product built through the NDZ approach.

A portable, declarative contract system for governing product development.

  • Declarative Contracts
  • Agent Governance
  • Open Source
Explore the product →
02

Webeloper

Can an AI system allow someone without technical skills to run the complete sales and delivery workflow of a website business?

  • 3 Agents
  • 2 Contracts
  • Human sales
Explore the project →

03 — More experiments in development

New systems are built not only to ship software, but to continuously test and improve the development infrastructure itself.

08 — The R&D Loop

Build. Measure. Learn. Rebuild the system.

Every product becomes an experiment.

Every experiment improves the system.

Every improvement changes what can be built next.

Build product
Observe the process
Identify bottlenecks
Improve the system
Build faster / better
Next product

NDZ Labs is not trying to predict what the future of software development will look like.

It is building it one product at a time.

09 — About / Founder

Built by Francisco Fernández

Francisco is an AI Product Architect and product builder with 6+ years of experience taking digital products from definition to production.

His work sits at the intersection of product strategy, software architecture, AI and hands-on development.

NDZ Labs started as a personal R&D environment to explore faster ways of building products. The development system emerged from that work — first as an internal tool, and later as a broader architecture with potential applications beyond NDZ itself.

Have a product worth building?

Bring us the problem.

We'll help define the system, find the fastest path forward and build what comes next.

Start a conversation →

NDZ Labs

Independent AI Product R&D

Buenos Aires · Working globally