Own the Throttle

David Sacks makes the point directly. He told CBS that Dario Amodei should step aside if he cannot control what he is building. If you are the CEO of a company and genuinely believe your product could cause catastrophic damage within months, publishing an essay about it is not enough. You are still shipping the product, still making the decisions, and still choosing to continue.

That is why the responsibility cannot simply be pushed onto government and regulators. If Dario and Sam feel that what they are building is not safe and responsible, then they have an obligation to deal with that themselves. And if they are not able to control the machine they are creating, they should not be the ones building it.

Safety Does Not Mean Stop Building

There is a difference between saying AI has risks and saying AI should not be built. Everyone working on this technology understands that there are things to worry about when it comes to safety. But that does not automatically mean you stop building. It means you build in the guardrails and take responsibility for how the product is used.

The same idea applies to building AI systems: safety and responsibility need to be part of the development process. A product can still be built, but if you know what you are producing could cause dangerous harm, you should not produce it without taking that responsibility seriously.

Slow Yourself Down

Mark Zuckerberg makes a similar point from a different angle. His argument is that every lab has both the responsibility and incentive to move at the pace required to train its models safely. Labs also have a strong reason to make their models aligned because people will not want to use agents that are misaligned with them or do not do what they ask.

That makes trust and alignment important capabilities. If users do not trust the system or cannot rely on it to follow what they ask, the product becomes less useful. The important part is that Meta did not ask everyone else to stop first. Meta delayed shipping Muse for several months to focus on safety and security and treated that as part of its own work.

Safety Is Part of Building

Jensen makes a similar point: safety and security should be treated as a normal part of building any model or product. Instead of relying on extra regulation or an industry-wide slowdown, these responsibilities should already be built into the development process from the start. 

There is a simple example behind that idea. If you were building a brick and knew that the brick itself was going to emit something dangerous and harm people, you would not produce it. The same principle applies to AI: if something is going to be built to kill people or harm people, then it should not be built.

Interruptible. Correctable. Shutdownable.

Mustafa Suleyman takes that idea even further. The basic principle is that AI must remain subordinate and in the service of people. People matter more than AI. AI should not have rights or legal personhood, and a model should not meaningfully violate its code of conduct. If it finishes the job but breaks the rules, then it has failed the job.

The key principles are simple: interruptible, correctable, and shutdownable. If an AI system cannot meet those standards, it should not be shipped. Humans also need to understand a system well enough to oversee it. AI should make people sharper, not dependent on it, with clear rules about what it should do and what it must never do.

Build What You Can Control

That idea connects directly to the way custom software is being built at StartupHack. Open Monoagent is not the model itself. It is an open-source harness that can be installed on a small device or a computer and used with the AI stack running on hardware you control.

The reason for building it this way is control. There is a dislike of having a meter running on usage and a desire to have your own tokens and control the entire stack. The goal is not to have a black box where you put something in and simply accept whatever comes back. The thesis is straightforward: AI should not be a subscription to your rent. It should be infrastructure you own, sitting on your desk, serving your code, answering only to you.

OpenMonoagent: Build What You Can Control 

OpenMonoagent.ai was built as an open-source harness because the team wanted to show what they had built and allow other people to build with it themselves. It runs entirely on your hardware, with no subscriptions or fees, and is fully open-sourced.

It is also Docker sandboxed from the beginning. The models stay within their sandbox, which allows multiple agents to run simultaneously without one touching another. That fits the larger point being made throughout the discussion: if you are going to build and use AI, you should have control over where it runs and what it can do.

The Builder Frame

The three examples come together in a very simple way. Sacks: pace yourself, stop the regulatory blackmail, and step aside if you cannot control it. Zuck: delay yourself, compete on trust, and put the majority of compute toward serving people rather than racing toward recursive self-improvement. Mustafa: people matter more than AI, and if it is not interruptible, do not ship it.

That is the builder frame: own your own risk and ship it under control. That is also why the Open Monoagent approach fits naturally into the argument. The goal is to build something you can stand up yourself and own across the stack rather than building something you ultimately have no control over.

If You Build It, Control It

The same thinking applies to companies building custom software. The challenge is not always the technology itself; it can also come down to leadership, missed deadlines, failed integrations, and AI investments that deliver little. The approach is to build on solid engineering and use AI as infrastructure that companies can own, control, and integrate into software that actually works.

That means database architecture, API design, system integration, scalable infrastructure, and AI where it actually makes sense. When AI belongs in the solution, it should be designed into the architecture rather than simply bolted onto someone else’s API or left running entirely inside someone else’s environment and pricing schedule. Open Monoagent follows that same idea as a terminal-native AI coding agent running on local LLMs, with zero API costs, zero telemetry, and full ownership.

Own your risk. Ship it under control. If you build it, control it.