I think you are misunderstanding the way NaCl boxses work. NaCl encryption like you are doing it uses two algorithms. One symmetric one and another asymmetric. Specifically XSalsa20 (symmetric) and Curve25519 (asymmetric).
The way it works is as follows:
Curve25519 allows the generation of a shared 32 byte key given a public key and private key.
So basically you can generate the same shared key if you send your public key to someone and they send theirs to you. (The same key will be generated for both sides, but an attacker will not have your private keys, so they can't generate the shared key).
This is essentially what happens when you make a box. A shared key is derived from the public key you received and your own private key, and then used for encryption using XSalsa20.
Essentially after making the box, you are using symmetric encryption to encrypt stuff using the key derived from the key pair. Also it's the same key every time given the same key pair, you aren't making throwaway keys (and you don't need to make another box object every single time, they will all use the same key anyway, you can use the encrypt method with the same object).
As a side note, you should never reuse the same nonce again when encrypting messages so it's not safe at all to use 0 for every message.
Edit: You might be wondering why this is done. The reason is because asymmetric encryption is slow, and generally not so efficient for encrypting long messages. So in most cases, asymmetric encryption is only used either to exchange a symmetric key (or to encrypt a symmetric key that is used to encrypt the actual message and then send both the message and the encrypted symmetric key) or to generate one (like in this case).
Even in cases that don't deal with real-time communication, this is how it is generally done.
NaCl boxes work for continuous two-way conversation, so there is no need to make different throwaway key-pairs for every single message (you generate a single shared key and use it for conversation from that point forwards, generating a new key each time would be a waste of resources).
As long as the shared key itself and the private keys (which allow the generation of the shared key) are safe and you don't reuse a nonce, you should be safe.
I am not sure of your use case, but you can technically generate a random key pair each time too (however, this means you cannot determine if the message is from the same person as before obviously). If you want people to send you messages, in other words, one-way communication that is not real-time, you can technically do this too (again, this breaks the authentication).