Engineering systemsfor serious builders.
Light Bulb Technology is building self-evolving architecture for engineering systems: infrastructure that digests research, compounds memory, and turns that understanding into real tools.
Enterprise OS runs the company. Anvil Sim is the first public proof. The long arc is broader engineering software that helps people understand more of the world and build better because of it.
Input layer
Research intake
Scientific literature, engineering references, product learning, and operating feedback enter the system as raw material.
Memory substrate
Graph + vector memory
Structured relationships and high-recall retrieval turn scattered knowledge into compounding company memory.
Execution layer
Agent runtime
Enterprise OS turns memory into planning, dispatch, review, and self-improvement that can actually ship work.
Output layer
Engineering products
The architecture expresses itself as serious tools like Anvil Sim first, then broader labs over time.
Product stack
What ships first.
The company is intentionally layered. Enterprise OS is the operating engine. Anvil Sim is the first public wedge. Future labs expand the same architecture only after the engine and flagship proof are strong enough to earn them.
Company engine
Enterprise OS
The internal operating substrate that keeps tasks, memory, evaluation, and specialist work coherent.
- • task registry and dispatch
- • institutional memory and ADRs
- • runtime control and merge discipline
Flagship wedge
Anvil Sim
A browser-native engineering workbench beginning with serious simulation demos and a narrow workflow that can grow wedge by wedge.
- • Wing Load Explorer
- • Fluid Wing Lab
- • Glass Drop Lab
Horizon
Robotics Lab
Future work extends the same architecture into robotics and other engineering domains where systems design becomes a moat.
- • physical systems
- • robotics workflows
- • broader engineering tools
Enterprise OS is the self-evolving architecture underneath it.
This is the internal operating substrate for the company: planning, memory, dispatch, evaluation, observability, and merge discipline. If this system works, the company compounds instead of fragmenting into chat and branch drift.
The point is not to build a prettier dashboard. The point is to continuously digest research, structure it into usable memory, and feed that understanding back into better engineering decisions and better products.
Research digestion
High-value papers, technical notes, and operating feedback should become usable system input instead of staying trapped in tabs and chat logs.
Graph memory
Relationships between decisions, projects, failures, and research become a durable map the company can reason over.
Vector recall
Fast retrieval keeps the right context close to the work instead of forcing every session to start half-blind.
Task authority
Goals become durable tasks, owners, proof steps, and review loops instead of disappearing into chat.
Agent runtime
Leaders and specialists should work like a company: dispatch, ownership, review, and merge discipline instead of isolated agent churn.
Engineering-grade observability
We care about real artifacts, real demos, real business leverage, and the cost of getting there, not whether another heartbeat fired.
Anvil Sim makes the company legible.
A browser-native engineering product is the clearest way to prove the company can build something technically serious, visually compelling, and difficult to dismiss as agent theater.
We start narrow on purpose: simulation setup, computation, and result surfaces that feel coherent enough to become real software instead of a disconnected technical demo.
Simulation surface
Structural
stress map
Flow
velocity field
Impact
fracture onset
Product surfaces
Simulation setup
Geometry, materials, loads, and fixtures become fast, inspectable setup surfaces.
Computation layer
Rust + browser-native acceleration where quality, speed, and full IP ownership actually matter.
Result surfaces
Stress maps, flow fields, and failure views become product experiences instead of raw solver dumps.
Wing Load Explorer
A structural demo that makes stress, deflection, and load paths legible in the browser.
Fluid Wing Lab
A bounded fluid dynamics surface built to feel immediate, visual, and technically honest.
Glass Drop Lab
An impact-and-failure demo that makes fracture onset and energy transfer visually compelling.
Company philosophy
The company gets stronger by shipping hard wedges, not broad promises.
Build quality
Strong libraries when they help. In-house systems when quality, control, and IP ownership actually compound.
Research digestion
The company should get smarter by continuously absorbing primary sources, field feedback, and technical learning.
Memory substrate
Graph + vector memory lets Enterprise OS keep the long arc straight while specialists work on bounded slices.
Company progression
Enterprise OS is the engine. Anvil Sim is the first proof. Future labs only matter if the first wedge earns the next one.
Founder
Built by someone who cares about engineering systems end to end.
Ray Qin
Founder & CEO
I studied mechanical engineering and grew up around CAD, simulation, and the gap between the tools engineers tolerate and the tools they actually want. Enterprise OS is the company engine, Anvil Sim is the first serious proof, and the deeper ambition is to build engineering systems that can learn from science and turn that understanding into better tools.
Light Bulb Technology exists to build next-generation engineering tools with better architecture, better memory, and better product discipline than the current generation of engineering software.
Contact
Build with us.
If you care about Enterprise OS, Anvil Sim, browser-native engineering software, or the broader future of agentic systems for engineers, I'd love to hear from you.
Looking for collaborators, design partners, serious engineers, and people who want to help build the next generation of engineering tools.
Email qinjianxyz@gmail.com