Inheritance

Inheritance is a way to build a new class on an existing one, so the new class gets every method of the parent and changes only what differs.

Last updated: 30 Sep, 2026 · Python 3.14

Agent frameworks often hand you a base class and ask you to write one method. That is inheritance, built on Classes and Methods.

class Car:
    def __init__(self, windows, doors, enginetype):
        self.windows = windows
        self.doors = doors
        self.enginetype = enginetype

    def drive(self):
        print("The Person drives the car")

class Audi(Car):
    def __init__(self, windows, doors, enginetype, enableai):
        super().__init__(windows, doors, enginetype)
        self.enableai = enableai

    def selfdriving(self):
        print("Audi supports Self driving")

audiQ7 = Audi(5, 5, "diesel", True)
print(audiQ7.windows, audiQ7.enableai)
audiQ7.drive()

5 True
The Person drives the car

Audi never defines drive or windows; both come from Car, because super().__init__ ran the parent's setup. The model classes below follow the same pattern.

Syntax:

class Child(Parent):
    def __init__(self, a, b):
        super().__init__(a)    # run the parent's __init__ too
        self.b = b

A base class with one missing method

The base class below works for any model. It knows how to answer a list of texts, but not how to answer one:

class Model:
    def ask(self, text):
        raise NotImplementedError("a model must say how it answers")

    def ask_all(self, texts):
        return [self.ask(text) for text in texts]

Model().ask("refund please")

Traceback (most recent call last):
  File "main.py", line 8, in <module>
    Model().ask("refund please")
  File "main.py", line 3, in ask
    raise NotImplementedError("a model must say how it answers")
NotImplementedError: a model must say how it answers

ask_all calls self.ask for each text. ask itself only raises NotImplementedError, Python's standard way to say that a subclass must fill this in. Delete that line before you add the next example: an error stops the file where it happens.

Filling in the one method

class KeywordModel(Model):
    def ask(self, text):
        if "refund" in text.lower() or "charged" in text.lower():
            return '{"category": "billing", "priority": 4}'
        return '{"category": "other", "priority": 1}'

model = KeywordModel()
print(model.ask("Can I get a refund?"))
print(model.ask_all(["I was charged twice", "Hello"]))

{"category": "billing", "priority": 4}
['{"category": "billing", "priority": 4}', '{"category": "other", "priority": 1}']

class KeywordModel(Model) means KeywordModel inherits from Model. It gets ask_all without writing it, and its own ask replaces the one that raised. When ask_all calls self.ask, self is a KeywordModel, so the new version runs.

This is the pattern behind the stand-in models in the agent framework courses: subclass the framework's model class, write the method that produces an answer, and the framework's code does the rest.

Keeping the parent's __init__ with super()

class Model:
    def __init__(self, name):
        self.name = name

class KeywordModel(Model):
    def __init__(self, keywords):
        super().__init__(name="keywords")
        self.keywords = keywords

model = KeywordModel(["refund", "charged"])
print(model.name, model.keywords)
print(isinstance(model, Model))

keywords ['refund', 'charged']
True

A subclass with its own __init__ replaces the parent's, so name would never be set. super().__init__(...) runs the parent's version too. isinstance confirms a KeywordModel counts as a Model, which is what lets framework code accept it.

Parent vs child class

Where inheritance shows up in AI code

• Pydantic models inherit from BaseModel, as Pydantic models shows.
• Custom tools, models and callbacks in agent frameworks subclass a base class the framework provides.

Related

• Previous: dataclasses
• Next: Type hints
• Reference: Inheritance in the Python tutorial