How To Bear Responsibility For Artificial Intelligence?

The acclaimed science fiction writer Isaac Asimov devised the now well-known three laws of robotics far before today’s artificial intelligence revolution. Asimov’s laws are as follows:

First Law

A robot may not injure a human being or, through inaction, allow a human being to come to harm.

Second Law

A robot must obey the orders given it by human beings except where such orders would conflict with the First Law.

Third Law

A robot must protect its own existence as long as such protection does not conflict with the First or Second Law.

With the many decades that have passed by after Asimov devised these laws, the ethical questions surrounding the topic of artificial intelligence (AI) remains. The theme is getting more and more relevant by the day, as the applications of AI are accelerating through innovations.

This article aims to get to the heart of the matter by trying to answer (among others) a very difficult question: “Who should be held responsible if an artificial intelligence kills a human being by mistake?”

The Catch with Asimov’s Laws

Let’s consider the first two laws. At first glance, they sound logically rigorous. But when we consider first order and higher order consequences, they start to show their shortcomings. If this sounds confusing, let me elaborate using a simplified example. Let’s say that I order an AI to protect ‘human being 1’ at all costs. Let’s say that there arrives a situation where the said human being 1 comes under threat from another ‘human being 2’, and the ONLY way the AI can fulfil my order of protecting human being 1 is to kill the human being 2. If the AI does nothing (obeying the second law’s exception clause), human being 1 is killed by human being 2. In this case, the AI has violated the first law due to inaction. If the AI choses to defend human being 1 (disregarding the second law’s exception clause), human being 2 is killed, and human being 1 is safe. In this case, the AI has violated the first law due to action. Should we hold the AI or the creator responsible in either of these cases? How should we go about this?

This essay is supported by Generatebg

Humanity’s Solution So Far

One possible solution is for all code execution on computers to be done only with explicit approval from people who are trained enough in computer science so that they can understand what they are approving (which in itself is an assumptive approach). This way, humans would always be responsible for any actions taken by an artificial intelligence because they gave it an instruction to carry out in code. Although not perfect, such an approach would at least provide an answer to our main question: it’s always a human who would be held responsible. In fact, this is the approach that has been successfully implemented by regulators in the financial trading artificial intelligence space.

The technical term for code with explicit approval from humans is called safe code. Safe code prevents (in theory) situations where one order conflicts with another, because an artificial intelligence cannot act without explicit permission from its designer (a human being). Such safety measures try to ensure that there will never be situations like described above where an artificial intelligence has no way of deciding what option is better, leading it to make mistakes and harm any humans around it.

The Catch with Humanity’s Solution

However, safe code has also its share of problems. For instance, remember our hypothetical example with human being 1 and human being 2? At the point of attack from human being 2, the AI would contact the approver, asking them what to do. Due to the nature of the situation, the approver, who is a human being, would be faced with the same paradox. In such a scenario, the problem does not go away, but it just gets pushed to a human being. In other words, safe code makes people even more responsible than they already were! This new responsibility could lead some people to decline using AI altogether due to fear of self-incrimination later on if things go wrong while using something they approved previously. Other problems associated with safe code involve verifying whether the person approving some piece of software actually meant what they said or simply made some mistakes when approving it (e.g., ordering killing innocent people), among other things.

We can see now how safe code fails to give satisfactory answers to our main question. Without delving deeper into Asimov’s laws, I think it’s obvious that safe code does not solve our main problem. Luckily enough, there are other ways to go about solving the problem at hand.

An Alternative Approach

As shown above, Asimov’s first two laws are incomplete because they do not take into account first order consequences or higher order consequences. Let us consider an artificial intelligence that protects a human being at all costs. If there are no other humans around for help, but only other artificial intelligences with similar instructions, what would happen if there were a situation where two or more humans were in danger? The AI would have to pick one over the other. Let’s say the AI picked human being 1 over human being 2. This means that the chosen human being 1 is saved while human being 2 is harmed. Does this mean that we should hold the AI responsible for harming human being 2 due to inaction? How can we do that when our intention all along was to protect human being 1 and we never specified beforehand that we wanted absolute protection of both human beings 1 and 2? This would be unfair against our AI and perhaps even against humanity as a whole: we never specified absolute protection for everyone (which makes perfect sense). We simply wanted protection for those people who were supposed to be protected; intention is important here (think about army / special security personnel. They are not held responsible for killing ‘enemies’). What if we had specified beforehand that protection was absolute? Would this make everything alright? Perhaps not: let us further suppose that there was yet another human near whom our AI could have saved but it chose not to (because of its intention to protect someone else). Should we then hold our AI responsible for allowing ‘human being 3’ to come under harm? It may seem so at first glance, but human beings create their own destiny: this artificial intelligence merely followed orders given by a human being and decided which order was best among several things happening simultaneously. This does not seem fair either! Perhaps we should also hold those humans responsible who instructed our AI with conflicting orders! This is getting ridiculous: now we must blame every human somehow involved in such a decision-making process! Perhaps an action is better than no action.

What shall we do with such scenarios? The answer lies in search of a more general solution which goes beyond Asimov’s laws alone. This solution involves studying how problems arise from multiple perspectives, including those of developers and users alike. There is no single perspective on these matters which is gospel truth since everyone has different opinions on how things should be done and what priorities should be given according to circumstances. In fact, from one person’s perspective, others may seem completely wrong! However, by engaging in dialogue between different opinions from different perspectives, consensus may be reached on how things should work out according to their respective needs and circumstances. In light of how Asimov devised his three laws based on his own perspective as a scientist and writer, we can see that his laws are not necessarily the best way to go about preventing harm to humans. Asimov based his laws on how he thought things should be done; this is perfectly acceptable as long as we understand that it comes from a particular perspective. However, we must also be aware of other perspectives and consider them. For instance: perhaps our AI favors protecting one human over another because there is a much higher likelihood of human being 1 reaping benefits from the AI in the future compared to ‘human being 2’ who has a higher likelihood of harming other humans in the future.

The Bigger Picture

In light of how complex these problems actually are, let us pose a question: should we leave it all to Asimov’s laws alone? Or should we seek more general solutions? I think it is clear at this point that leaving things as they are would lead to various problems. So, what shall we do?

I would argue that if artificial intelligence were ever going to become so advanced as to fall under control of an entity with malicious intentions, then this entity would already have enough technology and / or resources at their disposal to achieve anything else they desire. In such situations, I believe it would be better to use artificial intelligence for good rather than letting it fall into the hands of those who want to use it for evil. This means giving up some control over our lives because, there will likely never be a way for us humans to prevent every single possible problem caused by artificial intelligence completely (as we haven’t solved this issue for human intelligence first). All we can do is make sure that those responsible for causing harm receive proper punishment. And this won’t happen unless someone takes responsibility!

Conclusion

So, who is responsible in cases where an artificial intelligence harms a human being? To answer this question in general terms, let us revisit the idea of multiple perspectives. We must take into account not only what developers think or want (e.g., programmers creating code), but also what users (e.g., end users using software / AI) think or want when taking actions with the software in general, including artificial intelligences. Both groups interact with each other through dialog between multiple perspectives when deciding how things should work out according to circumstances.

It seems like the best approach is ensuring that developers work alongside users when designing the AI. This way, each group works with the other to design artificial intelligence which suits both their needs and circumstances. If we take this approach, we will not be relying on how one particular person (e.g., Asimov) thinks things should work out; rather, we will use a general solution for problems that arises from multiple perspectives, including those of developers and users alike. This solution involves studying how problems arise from multiple perspectives and taking action accordingly: engaging in dialogue between different opinions from different perspectives and reaching consensus on how things should work out based on respective needs and circumstances. And this makes good sense because we live in a world where everyone has the right to think differently and decide what is best for themselves!

I hope you found this article interesting and useful. If you’d like to get notified when interesting content gets published here, consider subscribing.

Further reading that might interest you: AI Writes an Essay On Simulation.