NAQSH

NAQSH is an AI engineering agent for CAD that understands, builds, modifies, and tests designs with you, from scratch or alongside your work, turning ideas into engineered reality.

Comment

Inspiration

Engineering software is powerful, but engineering work is still highly manual. An engineer has to understand a design, remember its constraints, decide what should change, make the change, and then verify that the result is actually correct.

AI can suggest changes, but there is a deeper problem: how do you trust an AI system when it changes something important?

We built NAQSH around that question.

Instead of creating another chatbot that talks about engineering, we wanted to build an agent that can work alongside an engineer, understand the design and its constraints, propose actions, execute approved changes, and then prove what actually happened.

Our core idea is simple:

AI should not just generate an answer. It should understand the engineering task, act within boundaries, and verify its own work.

That led us to build NAQSH, an agentic engineering system designed around human control, structured project state, tool authorization, deterministic verification, and persistent project memory.

What it does

NAQSH acts as a human-in-the-loop engineering agent.

A user can give NAQSH an engineering objective or work with an existing design. NAQSH can inspect the project state, understand requirements and constraints, create a structured plan, propose modifications, and wait for human approval before performing protected actions.

Once approved, the action passes through a controlled tool system rather than allowing the model to directly modify the environment.

After the action, NAQSH verifies the result using deterministic checks.

The important loop is:

Observe → Understand → Plan → Propose → Approve → Act → Verify → Remember

NAQSH also maintains structured project history, including decisions, actions, revisions, experiments, approvals, and verification results.

Our first engineering environment is CAD, with FreeCAD used through an environment adapter. This allows the core agent architecture to remain independent of a particular engineering application.

The goal is not "ChatGPT with CAD buttons."

The goal is an engineering agent that understands:

the engineer → the goal → the design → the constraints → the tools → the environment → the verification → the project history.

How we built it

We built NAQSH as a modular TypeScript/Node.js system with clear boundaries between the agent, world model, tools, permissions, verification, and engineering environments.

The world model stores structured project state rather than relying on conversation history.

The agent system uses Google's Gemini models through the Google GenAI SDK to reason over project context and produce structured plans and proposed actions.

The tool system exposes typed operations with validation and metadata. Protected operations cannot bypass the authorization layer.

The permission system separates observation, explanation, suggestion, preparation, approved execution, and bounded autonomous execution.

The environment adapter prevents the core system from becoming coupled to FreeCAD. FreeCAD is simply the first engineering environment connected to NAQSH.

The verification engine is deliberately independent from Gemini. It performs deterministic checks on project state, constraints, dimensions, relationships, and other verifiable conditions.

We also implemented checkpoints, recovery, project history, persistent memory, background job handling, and security boundaries around tool execution and external research.

We used Google Cloud infrastructure as part of the deployment architecture, with Cloud Run, Cloud Build, Cloud Storage, Secret Manager, and related services supporting the system.

Challenges we ran into

The hardest part was not getting an AI model to generate text. It was making sure the AI could act without becoming the authority over whether its own actions were successful.

We had to carefully separate reasoning from execution and verification.

For example, Gemini can propose:

"Change this parameter."

But Gemini cannot simply declare:

"The modification succeeded."

The action must pass through the tool and permission layers, and the resulting state must be checked independently.

We also had to solve problems around project isolation, failed actions, restart recovery, authorization replay, external research safety, and preventing arbitrary code execution.

Another challenge was building an architecture that could eventually support multiple engineering environments without putting FreeCAD-specific logic throughout the application.

These constraints made the system more complicated, but they also became one of the most important parts of NAQSH.

Accomplishments that we're proud of

We are especially proud that NAQSH is not just an architectural concept.

The core agent loop is implemented and tested.

The system can:

  • inspect structured engineering state
  • create structured plans
  • generate typed proposed actions
  • require human approval for protected operations
  • execute authorized tool operations
  • verify results deterministically
  • detect discrepancies between expected and actual changes
  • maintain project history and memory
  • create checkpoints and recover from failures
  • run bounded background work
  • communicate with an engineering environment through an adapter

We also built extensive automated coverage across the monorepo, including real HTTP interactions, persistence, agent workflows, authorization, verification, UI behavior, and recovery paths.

Most importantly, we built NAQSH around a principle we believe is critical for agentic engineering:

An AI should be able to act, but it should never be allowed to decide by itself that its action was correct.

What we learned

We learned that building an agent is much more than connecting an LLM to a collection of tools.

The difficult problems are state, permissions, verification, recovery, uncertainty, and trust.

We also learned that human-in-the-loop systems work best when the human is not forced to manually control every tiny action. The agent should be able to reason and prepare meaningful work, while the human remains responsible for consequential decisions.

Another major lesson was that deterministic systems and generative AI have different jobs.

Gemini is excellent for understanding intent, reasoning about context, planning, and proposing strategies.

Deterministic software is better suited for authorization, calculations, validation, and verification.

NAQSH combines both instead of asking one system to do everything.

What's next for NAQSH

NAQSH currently focuses on establishing the foundation for an engineering agent, with CAD as its first environment.

The long-term vision is much larger.

We want NAQSH to progress from helping modify existing designs to helping users go from an engineering goal to a complete design.

Future capabilities include:

  • richer engineering requirement interpretation
  • clarification of missing requirements
  • from-scratch CAD generation
  • engineering research and technical knowledge retrieval
  • controlled design experimentation
  • multi-objective optimization
  • deeper project memory and design intent
  • asynchronous engineering work
  • additional CAD, simulation, EDA, and manufacturing environments

Ultimately, we want NAQSH to become a general engineering agent that can continuously understand the engineer, the objective, the design, the constraints, the environment, and the history of decisions.

The human remains in control.

The agent does the heavy reasoning and execution work.

And every consequential action should have evidence behind it.

Built With

Share this project:

Updates

Submission history