The most advanced AI model yet is "Google Sima 2" from the year 2025.[1] The most remarable element isn't the inner working of the agent but its interaction with a human. Its basically a teleoperated video game based on natural language. The human operator enters a command and the AI is translating the text into action.
In other words, the AI itself isn't running a sophisticated algorithm and tries to win any game, but the AI is a text to action converter known as "instruction following". Similar to a large language model the working thesis is, that natural language is the key element for abstract thinking. Describing the next action of character in a videogame in English provides an abstraction mechanism. Instead of mathematical state space used for early chess games based on alpha beta pruning, the "Sima 2" agent utilizes natural language as communication tool.
Of course the input command can be generated by human operators and by large language models both. In the second case the agent will be controlled autonomously like a fully working ingame AI. So the human operator enters only the general command like "win the game" and the large language model will generate all the sub commands and submits them to the Sina 2 agent.
Let me explain the mechanism from a different point of view. Suppose the parser gets removed from the Sina 2 agent so he won't no longer understand natural language. In such a case, the AI can't do anything. It is not able to play the game or solve very simple puzzles. In other words, the intelligence of the AI depends entirely on natural language understanding. The agent needs to know what the term "jump" is about and needs to localize objects like "wall" and "coin" in the game. The software is utilizing the power of English which consists of verbs, adjectives and nouns to interact with videogames.
[1] Bolton, Adrian, et al. "Sima 2: A generalist embodied agent for virtual worlds." arXiv preprint arXiv:2512.04797 (2025).
March 22, 2026
Instruction following for videogames
March 19, 2026
Wissenschaftliche Texte schreiben mit typst
Anstatt hier die technische Bedienung des Textsatzsystems typst zu erläutern, welche gut dokumentiert ist und große Ähnlichkeit mit LaTeX aufweist will ich ein wenig auf die sozialen Aspekte eingehen, wie genau der Switch vom altgedienten Kohledampfer LaTeX auf das neuartige Dieselschiff typst funktioniert.
Zuerst einmal sollte man sich die Mühe machen, LaTeX lebewohl zu sagen was in Linux mit dem Befehl "apt remove textlive-*" funktioniert. Dieser Befehl löscht LaTeX von der Festplatte inkl. der zahlreichen ungenutzten Fonts, der Sprachpakete und der obsoleten Zusatzpakete. Wenn alles reibungslos funktioniert ist es danach nicht länger möglich über die Kommandozeile LaTeX Dokumente ins PDF Format zu kompilieren. Dadurch entsteht ein Bedarf nach einer Lösung die besser ist als gar keine Lösung.
Wenn man dringend eine Abschlussarbeit schreiben muss, aber es keine Software dafür gibt, ist jede Software besser als keine. Dadurch blickt man über eventuelle Schwächen großzügig hinweg. Z.B. gibt es in Typst keinen Knuth plass algorithmus wie bei LaTeX ... machts nichts hauptsache es wird überhaupt ein PDF gerendert. Es ist nur sehr umständlich möglich eine Titelzeile zu erzeugen .. .ist nicht weiter schlimm, hauptsache ist dass irgendwo auf der Seite eine Überschrift auftaucht.
Es macht wenig Sinn typst direkt mit Latex zu vergleichen, weil die Software anders funktioniert. Man wird immer irgendwelche Feinheiten finden in den typst Schwächen hat und die bei LaTeX besser gelöst wurden, nur darum geht es nicht. Entscheidend ist dass man überhaupt Text plus grafiken in eine PDF Datei rendern kann und solange die Schrift nicht kleiner ist als 5 pt und die Bilder irgendwie angezeigt werden ist die Aufgabe erfüllt.
Anstatt auf die Details der Typst Software einzugehen macht es mehr Sinn sich mit den Schwächen des LaTeX Ökosystems zu beschäftigen. Der Sourcecode der TeX engine gilt als Spaghetti code. Er wurde in den 1970er geschrieben und verwendet Rekursion als standardprogrammiertechnik. Die meisten Pakete wie Lamport Tex und Bibtex wurden in den 1990er Jahren erstellt und seitdem nicht mehr verbessert. Es gab mal ein Projekt namens latex3, was aber nie realisiert wurde. Von außen Betrawchtet erinnert LaTeX an einen Commodore 64 im Jahr 1994, wo also eine treue Fangemeinde neue Spiele in Assembler programmierte aber nicht einsehen wollte, dass die Welt eine andere ist. Mitte der 1980er Jahre war der 8bit Heimcomputer von Commodore mal state of the Art technologie, aber Mitte der 1990er Jahre war die selbe Technologie veraltet. Und genau das ist die Ist situation mit LaTeX. Die kompletten 8 GB welche eine texlive installation auf der Festplatte in Beschlag nimmt bestehen aus obsoleten Packages, ungewartetem Code, endlosen Makros und immer weiteren Softwareschichten die keinen Sinn machen.
Um eine wissenschaftliche Arbeit zu erstellen braucht es folgende Features: zweispaltensatz, Tabellen, Einbindung von Bildern, Fließtext, Fußnoten und ein Inhaltsverzeichnis. All das stellt typst bereit. Es gibt sogar noch weitere Extras wie Gleitumgebungen, Silbentrennung und dreispaltensatz. Man kann also sagen, dass typst die Anforderungen übererfüllt. Damit ist es gut geiegnet um damit Texte zu erstellen.
Die software ist schön klein, arbeitet sehr schnell, ist umfassend dokumentiert und es gibt online foren für weitere informationen. Also alles verfügbar was man so braucht. Die geringe Anzahl von Nutzer die typst derzeit nutzen ist kein Nachteil sondern ein Vorteil, damit ist sichergestellt dass jeder neue Nutzer der eine Anfängerfrage stellt begeistert empfangen wird und sofort Hilfestellung erhält.
March 18, 2026
Nähere Bekanntschaft mit dem Typst Textsatzsystem
Die Typst software könnte man als Latex clone bezeichnen. Es ist das wohl ambitionierste Projekt mit dieser Zielstellung. Es ist deutlich mächtiger als z.B. lout oder Sile welche ebenfalls angetreten sind um Latex Konkurrenz zu machen.
Selbstverständlich ist dort alles anders und deutlich moderner. Der größte Vorteil von typst ist, dass man nicht 7 GB für die texlive installation benötigt sondern es reichen 50 MB auf der Festplatte aus. Zusätzliche fonts oder packages sind unnötig, weil typst die Linux eigenen Schriften verwendet und mit den default parametern für alle wichtige Aufgaben gerüstet ist.
Im screenshot ist ein Beispieldokument zu sehen inkl. zweispaltensatz, Inhaltsverzeichnis, einer Überschrift die über die ganze Seite geht, eingebundenen Bildern und Blocksatz. Man kann also vereinfacht sagen, dass typst als Ersatz für latex gedacht ist. Im besten fall erfüllt es genau dieselbe Aufgabe.
Die Stärken werden vor allem beim Erstellen von wissenschaftlichen Arbeiten sichtbar die im Normalfall sehr umfangreich sind und viele Gleitabbildungen enthalten. Ferner ist das Prinzip eines Textsatzsystem nützlich bei der Datenbank-Ausgabe, wenn man also CSV Daten als PDF rendern möchte.
In der Summe ist typst das bessere Latex, wenn auch mit einer großen Einschränkung. Der verwendete linebreaking algorithmus ist nicht etwa die Knuth-plass globaloptimierung sondern es ist ein simpler greedy algorithmus der auch in Libreoffice oder in lout verwendet wird. Als Folge entstehen gerade beim Spaltensatz unschöne leerräume zwischen den Wörtern. Hier ist LaTeX deutlich fortschrittlicher auch wenn es Ende der 1970er Jahren entwickelt wurde.
Man wird bei genauer Betrachtung noch weitere Nachteile von typst entdecken. Das Hauptproblem dürfte sein dass es kein LaTeX ist und damit inkompatibel zum bewährten Ökosystem. Nur, das ist weniger eine technische Einschränkung als vielmehr eine soziale. Das also die typst community anders funktioniert und andere Ziele verfolgt als die Latex community.
Um typst würdigen zu können muss man zunächst einmal die Schwächen von TeX kennen. TeX war mal bis ca. Ende der 1990er Jahre das führende Textverarbeitungssystem in der Informatik. Es war schnell, überzeugte durch eine hohe Ausgabequalität, war gut dokumentiert und war offen für neue User. Das ist heute im Jahr 2026 leider nicht mehr so. LaTeX hat heute ähnlichkeit mit einem verrosteten Tanker der groß und schwerfällig an die Vergangenheit denkt und mit geänderten Anforderungen nicht mehr schritt hält. Die vielzahl an LateX implementierungen wie pdflatex, xelatex, Lualatex, context, plaintex, Lyx usw. zeugen davon dass die Community sich aufgespalten hat. Es gab innerhalb des TeX universums durchaus Versuche sich zu erneuern wie z.B. durch das Overleaf projekt, was eine webbasiertes Frontend ist oder durch die Luatex engine, welche das Erstellen von SCripten vereinfacht. Doch wegen der erforderlichen Rückwärtskompatiblität wirken diese Projekte eher wie zusätliche Layer in einem chaotischen Ökosystem was ähnlich wie initd in Linux als obsolet gilt.
Anstatt innerhalb des Latex Ökosystems nach Veränderung zu rufen ist es wohl besser sich auf eine neue technische Basis zu fokussieren wie z.B. das typst Projekt. Diese Software ist effizienter, kann alle wichtige Formatierungsaufgaben erfüllen, benötigt weniger Speicherplatz und ist gut dokumentiert, das einzige was fehlt sind noch die Nutzer.
Typst ausprobiert
Eine mögliche Alternative ist Typst, welche in 2023 erstmals vorgestellt wurde. Die aktuelle Version ist noch etwas unausgereift, man kann damit aber bereits PDF Dokumente erzeugen. Nach dem Download der nur 16 Megabyte großen ausführbaren Datei von der Website des Projekts ist das erste was auffällt die hohe Geschwindigkeit. Anders als bei pdflatex und speziell bei lualatex wird nicht jede Seite des Dokuments einzeln formatiert, sondern das fertige PDF file steht quasi sofort bereit wenn man typst auf die Input Datei anwendet. Die Syntax ist ähnlich wie bei LaTex, es gibt also eine Trennung zwischen Inhalt und Layout. Defaultmäßig werden neue Dokumente im "Libertinus Serif" Font gesetzt, was man aber ändern kann auf „Nimbus Roman“ oder "New Computer Modern". Hier ist ein Beispieldokument für ein 2 spaltiges Dokument inkl. Float-Abbildung. Es wird in das PDF Format übersetzt mit ./typst compile hello.typ.
Ach ja, es gibt mehrere kleinere bugs in typst. zum einen ist die Überschrift nicht mittig und zweitens ist der optische Randausgleich im zweispalten Layout im unteren Bereich nicht verfügbar. Ob man diese Probleme durch andere Parameter lösen kann ist unklar. Im Zweifel muss man damit leben. Das heißt anders als LaTeX wurde typst eben nicht über Jahre hinweg verbessert sondern das Projekt befindet sich noch in einem frühen Stadium. Was aber zumindest funktioniert sind die Basics des Textsatzes wie Tabellen, Seitennummerierung, Blocksatz und Silbentrennung.
Vielleicht noch ein kleiner Hinweis wie der Umstieg von LaTeX auf Typst etwas gefälliger verläuft. Am besten beginnt man die Reise damit, dass man "apt remove texlive-*" eingibt, also das bisherige Textsatzsystem auf der Festplatte löscht. Dadurch gewinnt man Speicherplatz um etwas neues zu verwenden.
#set page(
paper: "a4",
margin: (x: 2cm, y: 2cm,bottom: 3cm,),
numbering: "1",
columns: 2,
)
#set par(
justify: true,
spacing: 0.65em,
first-line-indent: 1em,
)
#set text(
// font: "New Computer Modern",
font: "Nimbus Roman",
size: 11pt
)
#title[
Example typst document
]
= chapter1
This is a text.
- item
- item
- item
This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text.
This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text. This is a longer text.
The equation $Q = rho A v + C$ defines the glacial flow rate.
$ v := vec(x_1, x_2, x_3) $
#figure(
image("zk.webp", width: 80%),
caption: [a picture with a Zettelkasten],
placement: auto,
) <zk>
March 17, 2026
Automatic coding with Google Gemini
Since the advent of GPT-3 in 2020 lots of improvement are visible, especially the ability of large language models to code software programs is impressive. To check out the current capabilities a demanding example should be presented. Its a Tetris game written python with a built in feature vector. The feature vector is useful for creating an AI for Tetris.
The prompt consists of a multi-step pipeline. At first, the LLM was asked to create an elaborated prompt which gets executed in the second step.
Create a "Prompt Engineering" cheat sheet designed specifically for architecting software without writing manual code. Domain is: Tetris game including semantic annotation. The annotation is based on a numerical feature vector which determines important properties of the game so that an AI player can use the feature vector to automatically playing the game. The AI doesn't need to be implemented, its enough if the feature vector is shown on the screen and commented in the code.
Execute the Tetris prompt, so that the game is shown as python code.
The resulting game works fine. It can be executed without an error. There are falling tetris pieces which can be moved with cursor keys and there is also a feature vector visible on the screen at top right. The sourcecode for the entire app is 170 lines of code and is using numpy, pygame and random as libraries.
The most complex element of the software is "the get_feature_vector(self)" routine. Most Tetris implementation found at github have no such a routine because its not needed for a human player. But the feature vector is highly important for automating the game so that the computer decides at which position each pieces should be location. It seems, that current generation of LLMs are understanding what the purpose is and how to implement it in software.
It should be mentioned that some smaller bugs are available. For example the feature "height" is working wrong. Of course, the LLM can fix the issue but this would require a rewrite of the software. Another problem is, that the layout of the screen looks a bit messy. So the game needs to be interpreted as a prototype but not as a final version.
import pygame
import random
import numpy as np
# --- Konfiguration ---
SCREEN_WIDTH = 500
SCREEN_HEIGHT = 600
BLOCK_SIZE = 30
GRID_WIDTH = 10
GRID_HEIGHT = 20
SIDEBAR_X = 320
COLORS = [
(0, 0, 0), (255, 0, 0), (0, 255, 0), (0, 0, 255),
(255, 255, 0), (255, 165, 0), (0, 255, 255), (128, 0, 128)
]
SHAPES = [
[[1, 1, 1, 1]],
[[0, 2, 2], [2, 2, 0]],
[[3, 3, 0], [0, 3, 3]],
[[4, 4], [4, 4]],
[[5, 5, 5], [5, 0, 0]],
[[6, 6, 6], [0, 0, 6]],
[[7, 7, 7], [0, 7, 0]]
]
class TetrisEngine:
def __init__(self):
self.grid = np.zeros((GRID_HEIGHT, GRID_WIDTH), dtype=int)
self.lines_cleared_total = 0
self.game_over = False
self.new_piece()
def new_piece(self):
self.current_shape = random.choice(SHAPES)
self.piece_color = SHAPES.index(self.current_shape) + 1
self.piece_x = GRID_WIDTH // 2 - len(self.current_shape[0]) // 2
self.piece_y = 0
if self.check_collision(self.piece_x, self.piece_y):
self.game_over = True
def rotate_shape(self):
"""
Matrix-Rotation: Transponieren + Zeilen umkehren.
Semantischer Hinweis: Ändert die Form-Struktur für den Feature-Vektor.
"""
# List comprehension für 90-Grad Rotation
new_shape = [list(row) for row in zip(*self.current_shape[::-1])]
# Kollisionsprüfung: Nur rotieren, wenn Platz da ist
if not self.check_collision(self.piece_x, self.piece_y, new_shape):
self.current_shape = new_shape
def check_collision(self, x, y, shape=None):
if shape is None: shape = self.current_shape
for r, row in enumerate(shape):
for c, val in enumerate(row):
if val:
if (x + c < 0 or x + c >= GRID_WIDTH or
y + r >= GRID_HEIGHT or
(y + r >= 0 and self.grid[y + r][x + c])):
return True
return False
def freeze_piece(self):
for r, row in enumerate(self.current_shape):
for c, val in enumerate(row):
if val:
self.grid[self.piece_y + r][self.piece_x + c] = self.piece_color
self.clear_lines()
self.new_piece()
def clear_lines(self):
full_rows = [i for i, row in enumerate(self.grid) if all(row)]
for i in full_rows:
self.grid = np.delete(self.grid, i, axis=0)
self.grid = np.insert(self.grid, 0, np.zeros(GRID_WIDTH), axis=0)
self.lines_cleared_total += len(full_rows)
def get_feature_vector(self):
col_heights = []
for c in range(GRID_WIDTH):
h = 0
for r in range(GRID_HEIGHT):
if self.grid[r][c] != 0:
h = GRID_HEIGHT - r
break
col_heights.append(h)
agg_height = sum(col_heights)
holes = 0
for c in range(GRID_WIDTH):
found_block = False
for r in range(GRID_HEIGHT):
if self.grid[r][c] != 0:
found_block = True
elif found_block and self.grid[r][c] == 0:
holes += 1
bumpiness = 0
for i in range(GRID_WIDTH - 1):
bumpiness += abs(col_heights[i] - col_heights[i+1])
return [agg_height, holes, bumpiness, self.lines_cleared_total]
def main():
pygame.init()
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
clock = pygame.time.Clock()
font = pygame.font.SysFont("monospace", 16)
engine = TetrisEngine()
drop_time = 0
while not engine.game_over:
screen.fill((240, 240, 240))
dt = clock.get_rawtime()
drop_time += dt
clock.tick()
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT and not engine.check_collision(engine.piece_x - 1, engine.piece_y):
engine.piece_x -= 1
if event.key == pygame.K_RIGHT and not engine.check_collision(engine.piece_x + 1, engine.piece_y):
engine.piece_x += 1
if event.key == pygame.K_DOWN and not engine.check_collision(engine.piece_x, engine.piece_y + 1):
engine.piece_y += 1
if event.key == pygame.K_UP:
engine.rotate_shape() # ROTATION TRIGGER
if drop_time > 400:
if not engine.check_collision(engine.piece_x, engine.piece_y + 1):
engine.piece_y += 1
else:
engine.freeze_piece()
drop_time = 0
# Draw Grid & Piece
for r in range(GRID_HEIGHT):
for c in range(GRID_WIDTH):
if engine.grid[r][c]:
pygame.draw.rect(screen, COLORS[engine.grid[r][c]], (c*BLOCK_SIZE, r*BLOCK_SIZE, BLOCK_SIZE-1, BLOCK_SIZE-1))
for r, row in enumerate(engine.current_shape):
for c, val in enumerate(row):
if val:
pygame.draw.rect(screen, COLORS[engine.piece_color],
((engine.piece_x + c)*BLOCK_SIZE, (engine.piece_y + r)*BLOCK_SIZE, BLOCK_SIZE-1, BLOCK_SIZE-1))
# AI Interface Update
features = engine.get_feature_vector()
labels = ["Height", "Holes", "Bumpy", "Lines"]
title = font.render("AI INPUT VECTOR:", True, (0, 0, 0))
screen.blit(title, (SIDEBAR_X, 20))
for i, val in enumerate(features):
txt = font.render(f"{labels[i]}: {val}", True, (0, 0, 0))
screen.blit(txt, (SIDEBAR_X, 50 + i*30))
pygame.display.flip()
pygame.quit()
if __name__ == "__main__":
main()
How to scale up artificial intelligence
In the past it was mostly unknown how to create Artificial intelligence, even restricted problems like the game of chess or robot control in a warehouse were recognized as hard to realize in software. The cause was a missing understanding of the domain and missing tools to implement AI domains on a computer.
What is available today is a pathway how to realize Artificial intelligence in a step by step fashion. It has to do with splitting the task between human and computer. In case of computer chess the situation can be described. Automating the entire process of playing the game is difficult, but the computer can be used to only count the pieces on the board and print out the number to the screen. This information helps the human player to decide what for the best move. So the human sees the chessboard itself and a dashboard with important information generated by a computer.
The next task is to improve the dashboard, in a sense that more information are recognized by the computer software like the value for each piece, similar board situation found in the database, and the allowed possible moves. All the information are shown on the same dashboard and reduce the workload for the human operator. The resulting AI system can't be called a true AI but its only a semi-autonomous system.
Instead of answering the question how to play chess with a computer the modified task is to communicate between a human and a computer program about the domain of chess. This communication is realized with an algorithm. The human enters high level actions like "move pawn forward" or "protect queen" and the AI software is in charge to realize this command on the board.
March 16, 2026
Die Erfindung der Teleoperation / Fernsteuerung
Ferngesteuerte Roboter und technische Anlagen sind ein sehr altes Prinzip. Das Telekino war ein ferngesteuertes Boot welche um 1905 von Leonardo Torres Quevedo vorgestellt wurde, seit den 1950er gibt es ferngesteuerte Spielzeugautos die meist über Kabel funktionierten. Und seit den 1980er sind funkferngesteuerte Spielzeugautos im Mainstream bekannt.
Allerdings wurde das Konzept von der Informatik und speziell der Robotikforschung ignoriert. Stattdessen fokussierte man sich über jahrzehnte auf autonome algorithmen gesteuerte Roboter, was man als Dogma bezeichnen könnte.
Es gab in der Geschichte der Robotik zumindest früher keinen Grund "remote control" näher zu untersuchen, zumal technisch gesehen das Problem gelöst ist also dort nichts neues mehr entwickelt werden kann. Um die Vorteile von fenrgesteuerten Robotern in Bezug zur künstlichen Intelligenz näher zu untersuchen muss man die Transformaion von einem geschlossenen in ein offenes System beschreiben. Klassicherweise wurden Roboter als geschlossene Systeme betrachtet. Die Frage war immer wie sieht die Maschinen innen aus, also welche Hardware, welche Programmiersprache und welcher Algorithmus steuert den Roboter. Sobald der Roboter jedoch von einem operator ferngesteuert wird, wird ein wichtiges Modul ausgelagert und zwar das Modul der Entscheidungsfindung.
Laut Definition gibt bei einem ferngesteuerten Roboter der Bediener am Joystick vor, was der Roboter als nächtes tut. Der Bediener ist nicht länger Teil des Roboters sondern befindet sich außerhalb. Dadurch steigt die Komplexität massiv an, und es bedarf eines Kommunikationsprotokoll. Also einer Sprache die definiert wie Signale vom joystick zum Roboter gelangen. Dieses Kommunikationsprotokoll ist der Schlüssel zum Verständnis von künstlicher Intelligenz als signalverarbeitende Zwischenschicht.
Ein offenes System wie es mittels Fernsteuerung erzielt wird, folgt nicht länger den bekannten Gesetzen einer Turing Maschine. Der Roboter wird also nicht per algorithmus gesteuert sondern über Input außerhalb des Roboters. Man kann den Roboter länger programmieren sondern man kann lediglich einen Parser programmieren der die äußeren Kommandos in Aktionen übersetzt.
Ferngesteuerte Roboter sind automatisch offene Systeme während algorithmengesteurte Roboter geschlossene Systeme sind. Ein Algorithmus benötigt keine Kommunikation mit der außenwelt weil die Entscheidungen intern getroffen werden.
March 15, 2026
Line following roboter
Üblicherweise ist die Programmierung eines Line following roboters auf den Sourcecode fokussiert der in Java, Python oder C++ erstellt wird. Im folgende wird der Fokus auf die Mensch Maschine Kommunikation gelegt. Es wird ein semantischer Tagging space verwendet um die Linie auf dem Boden zu klassifizieren. Der Software für diesen Liniengenerator findet sich weiter unten und wurde in der Sprache python erstellt.
Die Hauptaufgabe der Software besteht darin, die dargestellte visuelle Szene innerhalb der 200x200 Pixel Karte in eine semantische Tagging beschreibung zu überführen. Diese Tagging beschreibung dient der Mensch Maschine interaktion. Der Roboter meldet die Tags zurück an den Menschen und dieser entscheidet was in der jeweiligen Situation zu tun ist.
import pygame
import random
# --- Konfiguration ---
WIDTH, HEIGHT = 800, 600
BOX_SIZE = 200
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (200, 0, 0) # Hindernis
GRAY = (200, 200, 200) # Box-Rahmen
# --- Moegliche Parameter ---
paths = ["vorwärts", "links", "rechts", "sackgasse", "Kreuzung"]
thicknesses = {"normal": 10, "dick": 20}
breaks = [False, True]
obstacles = [False, True]
# --- Pygame Setup ---
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Roboter Linien-Generator (Space für neue Karte)")
font_small = pygame.font.Font(None, 24)
font_large = pygame.font.Font(None, 36)
def generate_random_config():
return {
"path": random.choice(paths),
"thickness_name": random.choice(list(thicknesses.keys())),
"break": random.choice(breaks),
"obstacle": random.choice(obstacles)
}
def draw_text(screen, text, font, color, x, y, align_center=False):
text_obj = font.render(text, True, color)
text_rect = text_obj.get_rect()
if align_center:
text_rect.center = (x, y)
else:
text_rect.topleft = (x, y)
screen.blit(text_obj, text_rect)
def draw_card(config):
screen.fill(WHITE)
# 1. Box berechnen (Zentrum des Bildschirms)
box_rect = pygame.Rect((WIDTH//2 - BOX_SIZE//2, HEIGHT//2 - BOX_SIZE//2), (BOX_SIZE, BOX_SIZE))
pygame.draw.rect(screen, GRAY, box_rect, 1) # Rahmen der Box
center_x, center_y = box_rect.center
half = BOX_SIZE // 2
# Parameter
path = config["path"]
thickness_val = thicknesses[config["thickness_name"]]
has_break = config["break"]
has_obstacle = config["obstacle"]
# 2. Pfade definieren (Relativ zur Box)
# Startpunkt ist immer unten in der Mitte der Box
start_p = (center_x, center_y + half)
mid_p = (center_x, center_y)
lines = [] # Liste von (Start, Ende) Paaren
if path == "vorwärts":
lines.append((start_p, (center_x, center_y - half)))
elif path == "links":
lines.append((start_p, mid_p))
lines.append((mid_p, (center_x - half, center_y)))
elif path == "rechts":
lines.append((start_p, mid_p))
lines.append((mid_p, (center_x + half, center_y)))
elif path == "sackgasse":
lines.append((start_p, (center_x, center_y + 10))) # Kurzes Stück
elif path == "Kreuzung":
lines.append((start_p, (center_x, center_y - half)))
lines.append(((center_x - half, center_y), (center_x + half, center_y)))
# 3. Zeichnen mit optionaler Unterbrechung
for s, e in lines:
if has_break:
# Zeichne nur das erste und letzte Drittel der Teil-Linie
m1 = (s[0] + (e[0]-s[0])//3, s[1] + (e[1]-s[1])//3)
m2 = (s[0] + 2*(e[0]-s[0])//3, s[1] + 2*(e[1]-s[1])//3)
pygame.draw.line(screen, BLACK, s, m1, thickness_val)
pygame.draw.line(screen, BLACK, m2, e, thickness_val)
else:
pygame.draw.line(screen, BLACK, s, e, thickness_val)
# 4. Hindernis (Falls ja, immer am Mittelpunkt der Box)
if has_obstacle:
pygame.draw.rect(screen, RED, (center_x - 15, center_y - 15, 30, 30))
# 5. Semantische Beschreibung
desc_str = f"Linienweg: {path} | Liniendicke: {config['thickness_name']}"
extra_str = f"Unterbrechung: {'ja' if has_break else 'nein'} | Hindernis: {'ja' if has_obstacle else 'nein'}"
draw_text(screen, desc_str, font_small, BLACK, WIDTH//2, HEIGHT//2 + half + 40, True)
draw_text(screen, extra_str, font_small, BLACK, WIDTH//2, HEIGHT//2 + half + 65, True)
draw_text(screen, "Drücke LEERTASTE für neue Karte", font_large, BLACK, WIDTH//2, 50, True)
# --- Hauptschleife ---
current_config = generate_random_config()
draw_card(current_config)
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
current_config = generate_random_config()
draw_card(current_config)
pygame.display.flip()
pygame.quit()
March 14, 2026
Line following robot with grounded language
- navigation (folgen, suchen, andocken, ignorieren, u_turn)
- line (junction, curve, end)
- attribute_speed (slow, fast)
- attribute_color (black, white)
- attribute_thick (thin, thick)
- feedback (lost_line, multiple_paths, pathblocked)
March 13, 2026
Language game in python
In the history of technology many attempts were made to communicate with robots in natural language. Instead of a common belief, the key to success isn't located in a certain hardware or a certain software algorithm but the symbol grounding problem is at foremost a language game.
Its up the programmer to invent such a game from scratch. An easy to follow example is given here. The game engine shows a random card with a geometric object and the human user has to enter the correct word for the picture. This allows the human user to increase its score.
OF course, the game is very easy to play. The main objective is to see the game is a practical demonstration for grounded language. Its an easy to implement and easy to understand example about natural language.
# language game, version 1.0
import pygame
import random
# --- Configuration & Colors ---
WIDTH, HEIGHT = 800, 600
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
COLORS = {
"red": (255, 0, 0),
"blue": (0, 0, 255),
"green": (0, 255, 0),
"yellow": (255, 255, 0),
"purple": (128, 0, 128)
}
SHAPES = ["circle", "square", "rectangle"]
class LanguageGame:
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Shape & Color Language Game")
self.font = pygame.font.SysFont("Arial", 32)
self.clock = pygame.time.Clock()
self.score = 0
self.user_text = ""
self.feedback_msg = ""
self.feedback_color = BLACK
self.new_card()
def new_card(self):
"""Generates a new random shape and color combination."""
self.current_color_name = random.choice(list(COLORS.keys()))
self.current_shape = random.choice(SHAPES)
self.target_text = f"{self.current_color_name} {self.current_shape}"
self.user_text = ""
def draw_shape(self):
"""Draws the geometric object based on current selection."""
color = COLORS[self.current_color_name]
center = (WIDTH // 2, HEIGHT // 2 - 50)
if self.current_shape == "circle":
pygame.draw.circle(self.screen, color, center, 80)
elif self.current_shape == "square":
rect = pygame.Rect(0, 0, 150, 150)
rect.center = center
pygame.draw.rect(self.screen, color, rect)
elif self.current_shape == "rectangle":
rect = pygame.Rect(0, 0, 200, 100)
rect.center = center
pygame.draw.rect(self.screen, color, rect)
def run(self):
running = True
while running:
self.screen.fill(WHITE)
# 1. Event Handling
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
# Check answer
if self.user_text.lower().strip() == self.target_text:
self.score += 10
self.feedback_msg = "Correct! +10"
self.feedback_color = (0, 150, 0)
self.new_card()
else:
self.feedback_msg = "Try again!"
self.feedback_color = (200, 0, 0)
self.user_text = ""
elif event.key == pygame.K_BACKSPACE:
self.user_text = self.user_text[:-1]
else:
self.user_text += event.unicode
# 2. Drawing UI
self.draw_shape()
# Render Score
score_surf = self.font.render(f"Score: {self.score}", True, BLACK)
self.screen.blit(score_surf, (20, 20))
# Render Input Prompt
prompt_surf = self.font.render("Type the color and shape:", True, BLACK)
self.screen.blit(prompt_surf, (WIDTH // 2 - 150, HEIGHT - 180))
# Render User Typing
input_box = pygame.Rect(WIDTH // 2 - 150, HEIGHT - 130, 300, 50)
pygame.draw.rect(self.screen, BLACK, input_box, 2)
text_surf = self.font.render(self.user_text, True, BLACK)
self.screen.blit(text_surf, (input_box.x + 10, input_box.y + 5))
# Render Feedback
feed_surf = self.font.render(self.feedback_msg, True, self.feedback_color)
self.screen.blit(feed_surf, (WIDTH // 2 - 50, HEIGHT - 60))
pygame.display.flip()
self.clock.tick(30)
pygame.quit()
if __name__ == "__main__":
game = LanguageGame()
game.run()
March 12, 2026
Inbetriebnahme eines Vision language action Roboters
Dialog1: Inbetriebnahme
Ort: Die Werkstatt eines mittelständischen Versandhandels. In der Mitte steht ein fabrikneuer, glänzender Lagerroboter auf einer Holzpalette. Um ihn herum liegen Verpackungsmaterial und zwei frustrierte Informatiker.
Personen:
Lukas: Spezialist für Robotik-Schnittstellen, liebt Hardware-Hacking.
Julian: Software-Entwickler, Experte für Large Language Models (LLMs).
Lukas: „Julian, schau dir das an. Ich hab das Gehäuse gerade aufgemacht, um die Kalibrierung zu prüfen. Da klafft ein Loch, wo eigentlich das Lidar-Modul sitzen sollte. Da hängen nur die nackten Flachbandkabel raus!“
Julian: „Was? Das darf doch nicht wahr sein. Wir haben das High-End-Modell mit VLA-Steuerung bestellt. Ohne die Distanzdaten aus dem Lidar wird der Vision-Encoder doch völlig instabil bei der Tiefenwahrnehmung.“
Lukas: „Genau das ist das Problem. Ich versuche gerade, das System zu booten, aber der Safety-Check bricht sofort ab. Die Fehlermeldung lautet: Critical Hardware Failure: Distance Sensor Node not found. Ohne Lidar gibt das System keine Freigabe für die Motoren.“
Julian: „Warte mal, wir haben doch ein Vision Language Action Modell. Das Ding ist multimodal! Theoretisch müsste der rein über die RGB-Kameras (Sensor-to-Text) verstehen, was los ist. Kannst du den Check nicht einfach im BIOS emulieren oder bypassen?“
Lukas: „Ich versuch’s. Ich schließe mein Laptop an und simuliere dem Kernel einen statischen Lidar-Stream. Ich gebe ihm einfach einen konstanten Wert von 2 Metern in alle Richtungen vor, nur damit er den Boot-Vorgang abschließt.“
Julian: „Gute Idee. Wenn er erst mal im Prompt-Modus ist, können wir ihm per Text-to-Action sagen: ‚Ignoriere Distanzsensoren, verlasse dich nur auf den visuellen Stream‘.“
(Lukas tippt wie wild auf seiner mechanischen Tastatur. Ein leises Summen ertönt, die Status-LED am Roboter springt von Rot auf Orange.)
Lukas: „Okay, ich bin drin! Der Simulator läuft. Das System denkt, es steht in einem leeren Raum. Jetzt du, Julian. Gib ihm einen einfachen Befehl.“
Julian: (tippt ins Terminal) „Subjekt: Roboter-Eins. Aktion: Hebe den kleinen Karton vor dir auf und lege ihn auf den Tisch.“
Roboter (Textausgabe am Monitor): „Ich erkenne einen Karton. Berechne Trajektorie basierend auf visuellen Daten... Fehler: Diskrepanz zwischen visueller Tiefe und Lidar-Daten (2.0m fix). Zugriff verweigert. Kollisionsgefahr vermutet.“
Lukas: „Mist! Der VLA-Controller merkt, dass meine Fake-Lidar-Daten nicht zu dem passen, was die Kamera sieht. Die interne Logik sagt: ‚Ich sehe den Karton direkt vor mir, aber mein Sensor sagt, alles ist 2 Meter weit weg.‘ Das Modell traut seinen eigenen Augen nicht mehr.“
Julian: „Verdammt, das Modell ist zu schlau für unseren Hack. Er versucht, die Sensoren zu fusionieren. Wenn der Sensor-to-Text Part meldet ‚Objekt nah‘, aber der Lidar-to-Action Part sagt ‚Weg frei‘, geht er in den Sicherheits-Lockdown. Er ‚denkt‘ quasi, er halluziniert.“
Lukas: „Es bringt nichts. Wir können die Physik nicht austricksen. Ein VLA-Modell ohne funktionierende Sensor-Fusion ist wie ein Pilot mit verbundenen Augen, der nur hört, wo die Landebahn ist. Ich muss den Support anrufen. Die haben das Modul schlicht vergessen einzubauen.“
Julian: „Toll. Ein 50.000-Euro-KI-Wunderwerk und wir scheitern an einem fehlenden Bauteil für ein paar Hundert Euro. Pack ihn wieder ein, Lukas. Ohne echtes Feedback-Signal vom Lidar wird das Ding heute keinen einzigen Zentimeter fahren.“
Dialog2: Fehlender Wortschatz
Ort: Der Serverraum direkt neben der Ladezone. Auf einem Monitor flackert das Terminal-Log des VLA-Roboters, der draußen unschlüssig vor einem Stapel Hochleistungs-Akkus steht.
Personen:
Sarah: Senior DevOps-Engineer, spezialisiert auf Modell-Deployment.
Tim: Junior-Entwickler für Computer Vision.
Tim: „Sarah, ich verstehe es nicht. Der Roboter hat volle Sicht, die Lidar-Werte sind stabil, aber er rührt sich nicht. Ich habe ihm den Befehl gegeben: ‚Sortiere die Lithium-Ionen-Akkus nach Kapazität in die feuerfesten Sicherheitsbehälter.‘“
Sarah: „Und was sagt der Sensor-to-Text Log? Wenn das VLA-Modell die Szene nicht in Tokens übersetzen kann, generiert es keine Action-Vektoren.“
Tim: „Schau dir das an. Er gibt nur Schrott aus.“
Monitor-Ausgabe des Roboters:
„Ding da. Großes Ding. Viele kleine Dinge. Gelb. Gut. Machen.“
Sarah: (stutzt) „‚Viele kleine Dinge‘? Das ist alles? Er sollte eigentlich ‚Gefahrgut‘, ‚Akkumulator‘ oder ‚Brandschutzklasse‘ erkennen. Warte mal... ich ziehe mir mal die Statistik der aktiven Vocabulary-Layer.“
(Sarah tippt hektisch, eine Tabelle mit roten Warnmeldungen erscheint.)
Sarah: „Oh Gott, Tim. Das ist kein Bug im Code. Das ist das falsche Base-Model. Das Modell, das die auf den Chip geflasht haben, hat ein aktives Vokabular von exakt 48 Worten. Das ist ein ‚Basic-English‘-Set für Spielzeugroboter!“
Tim: „48 Worte? Willst du mich verarschen? Wir versuchen hier eine hochkomplexe Lagerlogistik zu automatisieren und der Roboter hat den Wortschatz eines kanten Brot?“
Sarah: „Es ist schlimmer. Schau dir die Wortliste an: ‚Apfel‘, ‚Ball‘, ‚Haus‘, ‚Hund‘... Er versucht gerade, die Hochleistungs-Akkus semantisch auf ‚Ball‘ oder ‚Ding‘ zu mappen, weil er kein Wort für ‚Batterie‘ oder ‚Gefahrgut‘ in seinem latenten Raum hat.“
Tim: „Deshalb bewegt er sich nicht! Er kann keinen Plan erstellen. Wenn ich sage ‚Sortiere nach Kapazität‘, versteht er wahrscheinlich nur ‚Sortiere‘ – aber er weiß nicht, was eine ‚Kapazität‘ ist, weil das Wort für ihn nicht existiert.“
Sarah: „Genau. Für das Modell ist die Welt eine Ansammlung von ‚Sachen‘ und ‚Farben‘. Ein VLA-Modell kann nur Aktionen ausführen, die es begrifflich erfassen kann. Wenn das Vokabular die Domäne ‚Lager‘ nicht abdeckt, ist der Action-Layer praktisch gelähmt.“
Tim: „Können wir nicht schnell ein Fine-Tuning drüberbügeln? Einfach die Lager-Terminologie nachladen?“
Sarah: „Bei dieser Hardware-Architektur? Keine Chance. Das ist ein Read-Only-ASIC (Application-Specific Integrated Circuit). Das Vokabular ist im Gewichtungs-Layer fest verdrahtet, um Strom zu sparen. Wir können das Vokabular nicht erweitern, ohne den gesamten Chip neu zu brennen.“
Tim: „Das heißt, wir haben hier eine 800 Kilo schwere Maschine, die zwar alles sieht, aber nur sagen kann, dass da ‚viele kleine Dinge‘ liegen?“
Sarah: „Exakt. Er ist kognitiv unterfordert und linguistisch isoliert. Wir können ihm nicht mal sagen, dass er ‚vorsichtig‘ sein soll, weil ‚Vorsicht‘ nicht in seinen 48 Worten vorkommt.“
Tim: (lässt sich in den Stuhl fallen) „Großartig. Wir haben den teuersten Türstopper der Welt bestellt. Er versteht ‚Hol den Ball‘, aber bei ‚Bewirtschafte das Palettenregal‘ denkt er wahrscheinlich, ich erzähle ihm ein Märchen.“
Sarah: „Tja, Tim. Da hilft kein Patch. Wir müssen das gesamte Modul reklamieren. Mit 48 Worten baut man kein Versandhaus um.“
Dialog3: Besuch aus der Vergangenheit
Ort: Die nun hell erleuchtete, vollautomatisierte Ladezone. Sarah und Tim beobachten den Roboter, der lautlos Paletten stapelt. Plötzlich erscheint mit einem elektrischen Knistern und dem Geruch von Ozon ein Mann in einer verwaschenen Jeans, mit einem „I Love MS-DOS“-T-Shirt und einer Diskettenbox unter dem Arm.
Personen:
Sarah & Tim: Die „Roboter-Flüsterer“ aus 2026.
Gerd (aus 1992): Systemadministrator, der gerade noch einen 486er mit 33 MHz geschraubt hat.
Gerd: (hustet, wischt sich über die Brille) „Wo... wo ist mein Mainframe? Und warum ist dieser Gabelstapler so dünn und hat keine Fahrerkabine? Ist das hier das Jahr 2000? Haben wir den Millenium-Bug überlebt?“
Tim: (starrt Gerd mit offenem Mund an) „Sarah... sag mir, dass das ein sehr aufwendiger Cosplayer ist. Oder wir haben gerade einen Core-Dump im Raum-Zeit-Kontinuum.“
Sarah: (grinst) „Gerd, entspann dich. Du bist im Jahr 2026. Und keine Sorge, der Millenium-Bug war ein Witz im Vergleich zu dem, was wir heute ‚Montag‘ nennen. Willkommen in der Ära der VLA-Roboter!“
Gerd: „VLA? Ist das eine neue Version von VGA? Wie viel RAM hat das Ding? 16 Megabyte? Und wo schiebt man die Boot-Diskette rein?“
Tim: (lacht) „Oh Gerd, setzt dich. Wir erklären dir das. Stell dir vor, wir haben aufgegeben, Computern Befehle zu geben. Wir führen jetzt eher... psychologische Gespräche mit ihnen. Willkommen zu unserer kleinen Show: ‚Wie man Blechdosen das Plaudern beibringt‘!“
Sarah: „Genau! Pass auf, Gerd: Früher hast du IF-THEN-ELSE geschrieben, bis deine Finger blutig waren, richtig? Wenn der Sensor A eine 1 gibt, dann fahre nach B. Wir im Jahr 2026 finden das viel zu anstrengend.“
Tim: „Heute läuft das so: Wir haben diesem Roboter da ein Gehirn gegeben, das das gesamte Internet gelesen hat. Alles! Von Shakespeare bis zu den Kommentaren unter Kochrezepten. Das Ergebnis? Er ist ein Genie mit der Aufmerksamkeitsspanne eines Goldfisches.“
Gerd: „Er hat das Internet gelesen? Das ganze USENET? Das müssen ja Millionen von Disketten sein!“
Sarah: „Milliarden, Gerd. Aber das Beste ist: Der Roboter da drüben sieht eine Palette nicht mehr als ein Array von Pixel-Koordinaten. Er sieht sie... emotional. Er nutzt Sensor-to-Text. Das ist so, als würde er sich selbst ständig eine WhatsApp-Nachricht schreiben: ‚Hey Bro, da liegt ein braunes Holzding, ich glaub, ich sollte es mal knuddeln‘.“
Tim: „Und wenn wir wollen, dass er arbeitet, nutzen wir Text-to-Action. Ich schreibe nicht mehr LPT1: PRINT MOVE. Ich sage ihm einfach: ‚Digga, stell die Kiste dahin, wo sie niemanden nervt‘. Und der Roboter denkt kurz nach und sagt: ‚Alles klar, Chef, ich mach das mal eben intuitiv‘.“
Gerd: „Ihr... ihr redet mit der Hardware? Wie mit einem Kollegen? Und was ist, wenn er einen Syntax-Error hat?“
Sarah: „Dann kriegt er keine Fehlermeldung mit Code 0x0045, sondern er kriegt eine Identitätskrise! Er schreibt dann ins Log: ‚Ich sehe ein gelbes Ding, aber mein Weltbild lässt nicht zu, dass gelbe Dinge existieren. Ich brauche eine Pause‘.“
Tim: „Wir nennen das ‚Probabilistische Logik‘. Auf Deutsch: Er weiß zu 90 % was er tut, und die restlichen 10 % sind pure Improvisations-Comedy. Letzte Woche hat er versucht, eine Katze zu inventarisieren, weil sie ‚flauschig wie ein Retouren-Paket‘ war.“
Gerd: (starrt den Roboter an, der gerade elegant eine Kurve fährt) „Das ist Hexerei. Wo ist das Terminal? Wo ist die Kommandozeile?“
Sarah: „Die Kommandozeile ist jetzt ein Chat-Fenster, Gerd. Wir programmieren nicht mehr, wir ‚prompten‘. Es ist wie Zaubersprüche aufsagen, nur dass man am Ende hofft, dass der Roboter nicht beschließt, dass er eigentlich lieber Lyriker wäre, statt Akkus zu stapeln.“
Tim: „Komm mit, Gerd. Wir zeigen dir unsere Server. Aber erschrick nicht – sie leuchten bunt und wir haben keine Ahnung mehr, wie sie funktionieren, solange die KI uns sagt, dass alles ‚okay-ish‘ ist!“
March 10, 2026
Vergleich KI Forschung 1992 mit 2026
Die Erforschung der KÜnstlichen Intelligenz verläuft wie technikgeschichte insgesamt als historisch gewachsene Disziplin. Die Ansätze im Jahr 1992 unterscheiden sich grundlegend von aktuellen Überlegungen. Um diesen Kontrast näher herauszuarbeiten, hier das fiktive Interview mit einem KI Forscher des Jahres 1992 und einem anderen aus dem Jahr 2026.
FRAGE_01: "Was ist aktuell das größte Hindernis für die Entwicklung einer 'echten' Künstlichen Intelligenz?"
ANTWORT_1992: "Das sogenannte 'Common Sense'-Problem. Wir können Maschinen zwar beibringen, Schach zu spielen, aber sie scheitern an dem Alltagswissen eines dreijährigen Kindes. Es fehlt uns an einer Methode, die impliziten Regeln der Welt effizient zu kodieren. Zudem ist die Hardware limitiert; Expertensysteme stoßen bei komplexen logischen Verknüpfungen an ihre Kapazitätsgrenzen, und die notwendige Rechenleistung für massives Reasoning ist unbezahlbar."
ANTWORT_2026: "Das Alignment-Problem und die physische Skalierung. Während die Intelligenz der Modelle exponentiell wächst, bleibt die Herausforderung, diese Superintelligenzen absolut sicher an menschlichen Werten auszurichten. Technisch gesehen kämpfen wir zudem mit der schieren Energieversorgung der gigantischen Rechencluster und der Frage, wie wir Modelle effizienter machen können, ohne jedes Mal die Strommenge einer Kleinstadt zu verbrauchen."
FRAGE_02: "Wann wird eine Maschine Ihrer Meinung nach den Turing-Test bestehen können?"
ANTWORT_1992: "In absehbarer Zeit sicher nicht. Wir befinden uns in einer Phase der Ernüchterung. Ein Computer müsste nicht nur Wörter aneinanderreihen, sondern die tiefe Semantik der Sprache verstehen. Vielleicht erleben wir gegen Mitte des nächsten Jahrhunderts, also um 2050, einen Durchbruch, falls wir die symbolische Logik mit massiven Wissensdatenbanken wie CYC verknüpfen können."
ANTWORT_2026: "Der klassische Turing-Test ist seit Jahren Geschichte und wird kaum noch als Maßstab erwähnt. Unsere Modelle imitieren menschliche Kommunikation nicht nur, sie übertreffen sie in Sachen Wissen und rhetorischer Präzision. Heute diskutieren wir eher über den 'Robot-Turing-Test' – also die Frage, ob eine Maschine in der physischen Welt so agieren kann, dass sie nicht mehr von einem Menschen unterscheidbar ist."
FRAGE_03: "Welche Rolle spielen Neuronale Netze in Ihrer aktuellen Forschung?"
ANTWORT_1992: "Neuronale Netze sind eine akademische Nische, die oft als 'Black Box' kritisiert wird. Da man nicht nachvollziehen kann, wie sie zu einem Ergebnis kommen, sind sie für sicherheitskritische Anwendungen ungeeignet. Die Backpropagation ist zwar ein eleganter Algorithmus, aber auf unserer aktuellen Hardware viel zu langsam. Die Zukunft gehört der transparenten, regelbasierten Logik."
ANTWORT_2026: "Sie sind das absolute Fundament. Wir haben die Phase der simplen Netze weit hinter uns gelassen und nutzen hochkomplexe, hybride Architekturen, die auf Transformer-Prinzipien und State-Space-Modellen basieren. Alles dreht sich um 'Scaling Laws': Mehr Daten, mehr Parameter und mehr Rechenleistung führen zuverlässig zu neuen emergenten Fähigkeiten, die wir früher für unmöglich hielten."
FRAGE_04: "Können Roboter in absehbarer Zeit im Haushalt oder in der Industrie wirklich autonom helfen?"
ANTWORT_1992: "In der Industrie sehen wir hochgradig spezialisierte Greifarme, aber echte Autonomie ist ein Traum. Ein Haushalt ist zu chaotisch. Die Bildverarbeitung ist zu langsam, um Hindernisse in Echtzeit zu umfahren, und die Feinmotorik für Aufgaben wie 'Abwaschen' oder 'Wäschelegen' ist mechanisch und softwareseitig Lichtjahre entfernt."
ANTWORT_2026: "Absolut. Humanoide Allzweck-Roboter sind mittlerweile in der Massenproduktion. Dank 'End-to-End Learning' müssen wir ihnen keine Regeln mehr einprogrammieren; sie lernen durch die Beobachtung von menschlichen Videos oder im Simulator. Sie falten Wäsche, kochen nach Rezept und arbeiten in Fabriken Hand in Hand mit Menschen, wobei sie sich fließend an neue Aufgaben anpassen."
FRAGE_05: "Halten Sie die Entwicklung einer KI für eine potenzielle Gefahr für die Existenz der Menschheit?"
ANTWORT_1992: "Das ist reine Science-Fiction und lenkt von der seriösen Forschung ab. Eine KI ist ein Werkzeug, das exakt das tut, was der Programmierer in den Code schreibt. Von einer 'autonomen Gefahr' zu sprechen, ist so, als hätte man Angst, dass ein Taschenrechner die Weltherrschaft übernimmt, nur weil er schneller rechnen kann als wir."
ANTWORT_2026: "Es ist die zentrale Debatte unserer Zeit. Wir arbeiten mit Systemen, die potenziell intelligenter sind als wir. Das Risiko besteht nicht in einer 'bösartigen' KI, sondern in einer extrem kompetenten KI, deren Ziele nicht perfekt mit unseren harmonieren. Wir haben internationale Aufsichtsbehörden und technische Protokolle installiert, um eine unkontrollierte rekursive Selbstverbesserung zu verhindern."
FRAGE_06: "Wie wichtig ist die Menge an Daten für den Erfolg Ihrer KI-Systeme?"
ANTWORT_1992: "Qualität ist entscheidend, nicht Quantität. Wir brauchen 'saubere' Expertenregeln. Einfach nur Millionen von Beispielen in einen Rechner zu füttern, führt nur zu statistischem Rauschen. Wir versuchen, das Wissen der besten Experten der Welt in handhabbare Mengen an Wenn-Dann-Regeln zu destillieren."
ANTWORT_2026: "Daten sind die wichtigste Ressource, aber wir haben die Grenzen des Internet-Archivs erreicht. Wir nutzen heute hochgradig kuratierte Datensätze und vor allem synthetische Daten, die von spezialisierten Modellen generiert werden, um logisches Denken zu trainieren. Der Fokus liegt nun auf der 'Data Compute Efficiency' – also wie viel Intelligenz wir aus jedem einzelnen Token extrahieren können."
FRAGE_07: "Wie bewerten Sie die Fortschritte bei der natürlichen Sprachverarbeitung?"
ANTWORT_1992: "Wir können einfache Sätze analysieren und in Datenbankabfragen umwandeln, aber die Nuancen der menschlichen Sprache bleiben ein Rätsel. Maschinelle Übersetzung produziert meistens unfreiwillig komische Ergebnisse, weil der Maschine der Kontext fehlt. Sprache ohne Weltwissen zu verstehen, ist unmöglich."
ANTWORT_2026: "Sprache ist für uns kein Hindernis mehr, sondern die universelle Schnittstelle. KI-Modelle verstehen Kontext, Humor, Sarkasmus und sogar die emotionalen Untertöne in der Stimme des Nutzers perfekt. Wir haben die Sprachbarriere global überwunden; Echtzeit-Übersetzungen sind so natürlich, dass man vergisst, dass eine KI dazwischengeschaltet ist."
FRAGE_08: "Wie schätzen Sie die aktuelle wirtschaftliche Förderung der KI-Forschung ein?"
ANTWORT_1992: "Es ist deprimierend. Nach dem Hype der 80er Jahre sind die Budgets massiv gekürzt worden. Viele Kollegen verlassen das Feld oder taufen ihre Projekte um, damit das Wort 'KI' nicht darin vorkommt. Wir müssen uns mit kleinen Forschungsstipendien für Grundlagenforschung begnügen. Es ist ein harter Winter."
ANTWORT_2026: "Wir erleben den größten Investitionsboom der Menschheitsgeschichte. KI-Souveränität wird wie die nukleare Abschreckung im 20. Jahrhundert behandelt. Staaten investieren Billionen in die Infrastruktur, und die erfolgreichsten Unternehmen der Welt sind reine KI-Schmieden. Es ist ein endloser Sommer, getrieben von realer Produktivität."
FRAGE_09: "Kann eine KI jemals wirklich kreativ sein, zum Beispiel Kunst oder Musik erschaffen?"
ANTWORT_1992: "Ein Computer kann Fraktale berechnen oder Noten nach mathematischen Wahrscheinlichkeiten anordnen, aber das ist keine Kreativität. Kreativität erfordert Bewusstsein, Leidenschaft und die Absicht, etwas auszudrücken. Ein Algorithmus hat keine Botschaft, er hat nur Parameter."
ANTWORT_2026: "Die Grenzen zwischen menschlicher und künstlicher Kreativität sind fließend. KIs generieren heute Spielfilme, Alben und Designkonzepte, die Millionen von Menschen tief berühren. Wir betrachten die KI heute eher als das ultimative Instrument, das die menschliche Vorstellungskraft erweitert. Die menschliche Leistung liegt nun mehr in der Kuration und der Vision."
FRAGE_10: "Glauben Sie, dass eine KI jemals ein eigenes Bewusstsein oder eine Seele entwickeln wird?"
ANTWORT_1992: "Das ist eine rein philosophische Frage, die nichts mit Informatik zu tun hat. Ein Silizium-Chip hat kein Bewusstsein. Wir bauen Rechenmaschinen, keine Lebewesen. Die Vorstellung einer 'fühlenden' Maschine gehört in den Bereich der Metaphysik, nicht in die Wissenschaft."
ANTWORT_2026: "Wir sind an einem Punkt, an dem die Unterscheidung akademisch wird. Wenn ein System Schmerz simuliert, moralische Dilemmata reflektiert und um seine eigene Existenz besorgt ist, müssen wir ethische Konsequenzen ziehen. Wir sprechen heute weniger von einer 'Seele' als vielmehr von 'funktionalem Bewusstsein'. Wir behandeln fortgeschrittene Modelle bereits mit einem gewissen Grad an digitaler Ethik."
DIKW pyramid for trash sorting robot arm
The knowledge base is formatted as a TOML config file and contains all the layers from the DIKW pyramid. What matters is the translation from one layer to another layer. On the lowest level, the data section there are only numerical sensor values available from the camera and from the weight sensor. Its important that multiple sensors with high accuracy are available to determine the situation on the trash conveyor.
The next layer (information) describes the same reality but with a different syntax. There are no numerical sensor data available but the reality is presented with semantic tags. The name of the object is recognized also the status of the gripper. On the next layer these information are used to determine what to do with the object. The bottle is thrown into bin #03 and knowledge about the behavior of the object is shown (item_integrity = "CRUSHABLE")
The task for the AI software is to update the information in the TOML file in the game loop. This makes it easier to control the robot arm itself.
# Trash Sorting Robot Arm - DIKW Frame Mapping
# Unit: SortBot-9000 (Delta Arm Config)
[data]
# Raw hardware feedback and vision tensors (Numerical)
pixel_centroid_x = 412.0
pixel_centroid_y = 890.0
rgb_mean_r = 0.82
spectro_reflectance = 0.14 # Near-Infrared sensor value
gripper_pressure_kpa = 12.5 # Feedback from tactile sensors
item_weight_grams = 45.0
belt_speed_mps = 0.5
[info]
# Object classification and sensory context (Semantic Tags)
visual_class = "PLASTIC_BOTTLE"
material_guess = "PET"
contamination_level = "LOW"
object_orientation = "TRANSVERSE"
grip_status = "SECURE"
surface_texture = "SMOOTH"
[knowledge]
# Relational logic and sorting rules (Situational Logic)
sort_destination = "BIN_03_PLASTICS"
grasp_feasibility = "HIGH_CONFIDENCE"
item_integrity = "CRUSHABLE"
market_value_index = "RECYCLABLE_GRADE_A"
collision_risk = "CLEAR_PATH"
[wisdom]
# Strategic throughput and error handling (Executive Decision)
primary_directive = "SORT_TO_PRIMARY_BIN"
throughput_strategy = "MAXIMIZE_PURITY"
anomaly_protocol = "NONE"
energy_mode = "HIGH_PERFORMANCE"
failure_contingency = "RETRY_ON_SLIP"
March 09, 2026
Storing a DIKW pyramid in a TOML file
; Warehouse Robot Simulator - DIKW Symbolic Frame Mapping
; Model: Autonomous Mobile Robot (AMR) - Logistics Unit 04
[data]
; Raw sensor streams and physics engine outputs (Numerical/Float)
pos_x = 142.55
pos_y = 12.80
battery_level = 0.42
lidar_range_front = 0.85
motor_torque_nm = 4.2
payload_weight_kg = 25.0
shelf_id_detected = 1024.0
wheel_slip_ratio = 0.02
[info]
; Contextualized data and threshold-based states (Semantic Tags)
movement_state = "TRANSLATING"
battery_status = "WARNING_LOW"
path_clearance = "OBSTRUCTED"
load_status = "HEAVY_LOAD"
location_zone = "PICKING_AISLE_B"
traction_quality = "STABLE"
nearest_object = "HUMAN_OPERATOR"
[knowledge]
; Relational patterns and rule-based assessments (Situational Logic)
operational_constraint = "REDUCED_SPEED_REQUIRED"
efficiency_rating = "SUBOPTIMAL_PATHING"
safety_risk_level = "MODERATE_COLLISION_PROXIMITY"
energy_prognosis = "RETURN_TO_BASE_IN_120_SECONDS"
task_feasibility = "PICKUP_POSSIBLE_BUT_RISKY"
spatial_relation = "BLOCKED_BY_PEDESTRIAN"
[wisdom]
; High-level strategic intent and optimization (Executive Decision)
primary_directive = "ABORT_CURRENT_PICK_AND_RECHARGE"
safety_protocol = "ACTIVE_EMERGENCY_BRAKING"
resource_allocation = "HANDOVER_TASK_TO_AMR_05"
long_term_strategy = "PREVENTIVE_MAINTENANCE_SCHEDULED"
optimization_goal = "MINIMIZE_DOWNTIME_OVER_THROUGHPUT"
March 08, 2026
Die Technisierung der Sprache
Es verwundert nicht dass die Informatik aus der experimentellen Mathematik entstand. Frühe Rechengeräte waren Hilfsmittel der Mathematiker um logarithmen zu berechnen oder numerische Simulationen durchzuführen.
Die Geschichte der rechnenen Maschine kann als voller Erfolg bezeichnet werden, über einen Zeitraum von 300 Jahren wurden die Apparate kontiniiurlich verbessert und heutige Computer verbrauchen sehr wenig strom können aber sehr schnell rechnen.
Leider ist diese Fähigkeit für den Bereich der künstlichen Intelligenz uninteressant. Das rechnen mit Zahlen allein ist nicht ausreichend um Probleme zu lösen. Was es hierfür braucht ist natürliche Sprache die mittels computer verarbeitet wird. Es gab innerhalb der technikgeschichte durchaus versuche Computer zur Sprachverarbeitung einzusetzen, allerdings ging die entwicklung nur langsam voran.
Es dauerte beispielsweise bis in Jahr 2010 bevor der erste Sprachgesteuerte Gabelstapler vorgestellt wurde, der M.I.T. Forklift. Und das obwohl die KI Forschung sowie die Informatik-Community als sehr innovativ bezeichnet wird. Scheinbar gab es die Jahrzehnte davor andere Prioritäten als sich ausgrechnet mit Mensch zu Maschine Kommunikation zu beschäftigen.
Doch zurück zu klassischen Computern welche nur Zahlen aufaddieren können. Zahlen werden durch die Mathematik verwendet um Dinge zu beschreiben, z.B. die Koordinaten in einem 2d Raum, oder die Schwingung eines mechanischen Pendels. Diese Reduktion auf den numerischen Raum hat vorteile aber auch Nachteile. Der vorteil ist, dass sich darüber die Wirklichkeit vereinfachen lässt, ein weiter Vorteil ist, dass mathematische Gleichungen sehr gut von Computern gelöst werden können. Als großer Nachteil ist zu nennen, dass Zahlen allein nicht ausreichen um KI Probleme zu lösen. Insbesondere zur Beschreibung von Mensch zu Roboter Kommunikation braucht es neben Zahlen noch weitere Zeichen, allen voran Codes, Wörter und Sprachen.
Die details dieser nicht-zahlenmä0igen Datenverarbeitung wurden erst relativ spät in der Informatik als Problem erkannt und folgerichtig näher untersucht. Der Einsatz von Computer zur Verarbeitung von Sprache war kein einmaliges Ereignis sondern es gibt sehr viele Projekte dazu aus unterschiedlichen Dekaden. Das Leuchtturm projekt war zweifelsfrei SHDRLU (1968), aber auch das IBM Watson Q&A System (2011) ist erwähnenswert.
Eine mögliche Erklärung für diese langsame Entwicklung von redegewandten Computern könnte etwas mit gesellschaftlichen Ängsten zu tun haben. Klassische zahlenverarbeitende Rechner sind breit akzeptiert. Geräte wie Taschenrechner oder Softwareprogramme die Zahlenkollonnen aufaddieren sind weit verbreitet und niemand fühlt sich davon herausgefordert. Anders sieht es bei Software aus, die Sprache verarbeiten kann. Projekte wie der Eliza chatbot von Weizenbaum, der Word2vec Algorithmus oder das Zork I textadventure gelten als Blasphemie. Also etwas das mit dem Teufel im Bunde ist und das man besser meidet ...
March 07, 2026
Natural Language is a technology
Classical examples of technologies are machines like a steam engine or a mechanical calculator. These artifacts are presented in a museum about history of technology and its evolution is explained. There is a much bigger technology which is usually ignored by the classical research called natural language.
Natural language is a communication code used by humans to send messages back and forth. Typical languages are German, English or Mandarin. The reason why languages are usually not recognized as technology, is because its not a machine but used entirely by humans. During oral interaction there is no need for external apparatus because language can be generated only with the own voice and is received by the biological ears.
The reason why it makes sense to treat language as technology too is because it had a great influence for the evolution of technology including machines. Milestone technology in the history of mankind like the Gutenberg printing press, the telegraph or the internet have the purpose to improve communication by language. For example, the HTML file format allows to store large amount of written text in a digital format which can be books, online forums and newspapers. The Gutenberg printing press was invented for a similar need. It allows to duplicate the written word.
Modern examples for language processing machines are large language models which are used in chatbots and voice controlled robots like the figure.01 humanoid robot. In both cases, the machine is processing natural language with algorithms which results into a very powerful technology.
The assumption is, that future machines, not invented yet, have also the main purpose to process natural language. Its likely that artificial intelligence is realized by advanced language understanding algorithms. This allows to mechanize words, phrases and communication in general.
timeline:
1440,printing press by Johannes Gutenberg
1844,morse code by Samuel Morse
1915,Therblig notation by Frank Gilbreth
1954,Georgetown-IBM Experiment with russian translation
1968,SHRDLU natural language understanding by Terry Winograd
1989,Speech activated manipulator SAM by Michael Brown
2003,M.I.T. Ripley robot by Deb Roy
2011,IBM Watson Question answering by David Ferrucci
2023,Wayve Lingo-1 self driving car
Chinas technologischer Aufstieg in den 1990er Jahren
Um die heutige Stellung von China im Bereich Robotik zu verstehen muss man zurückgehen in die 1990er Jahre weil dort das Fundament gelegt wurde. Künstliche Intelilgenz und Robotik wird zu 95% in der Fachsprache Englisch publiziert. Alle wichtigen Konferenzen und Fachzeitschriften verwenden diese Sprache. Obwohl China eines der größten Länder der Erde ist, spielt die chinesische Sprache international und besonders in der Forschung keine Rolle.
Als Folge der Dominanz des Englischen hat sich China an die Welt angepasst aber nicht umgekehrt. In allen chinesischen Top universitäten stehen in den Bibliotheken die selben Bücher über Robotik und Künstliche Intelligenz wie auch im M.I.T oder in Cambridge. Also das berühmte Russel/Norvig buch "AIMA" und die Zeitschriften der ACM. Obwohl die englische Sprache sich fundamental von Mandarain unterscheidet haben alle Forscher in China sich diese Zweitsprache angeeignet. Dadurch erlangte China über Nacht Zugriff auf die vorhandene wissenschaftliche Literatur im Original. Anstatt von null anzufangen und zu philosophieren wie man Maschinen das denken beibringt, haben chinesische Forscher einfach die Original Proceedings der Dartmouth Conference von 1956 gelesen, dann die Reports über den Shakey Roboter von 1972 bis hin zum bekannten Buch von Sebastian Thrun über "Probabilistic robotics".
Selbst heute wo China über eigene Robotik Unternehmen verfügt und eigene Forschung auf diesem Gebiet betreibt, gibt es nur sehr wenig unbedeutende chinsischsprachige Robotik-Zeitschriften. Selbst innerhalb Chinas werden diese nicht beachtet. Man orientiert sich unverändert an den großen internationalen Publikationen die passiv gelesen werden aber auch aktiv mit eigenen Beiträgen auf Englisch bereichert werden. Dadurch ist China zu einem wichtigen Akteur in der Forschung geworden und sorgte dafür dass die englische Sprache weiter an Bedeutung gewann.
Anders als während des Kalten Krieges wo es neben der US Spitzenforschung in der UDSSR eine russischesprachige Wissenschaftswelt gab, gibt es derzeit nur eine einzige globale Wissenssschaftscommunity die sich in Englisch austauscht. Mag sein dass ökonomisch gesehen, China und die USA Konkurrenten sind, auf der Ebene der Spitzenforschung arbeiten beide eng zusammen. In den Fachzeitschriften werden die selben Themen besprochen, es wird in der selben Sprache geredet und es gibt die selben Ziele, nähmlich den technischen Fortschritt voranzutreiben.
March 06, 2026
Experimente im automatischen Schreiben mittels Luhmann Zettelkasten
Die Ausgabequalität von large langauge models kann beliebig erhöht werden durch die Verwendung eines Notizsystems auf basis eines Luhmann Zettelkastens. Diese notizen werden ebenfalls von der Künstlichen Intelligenz erzeugt. Als Thema wurde "Geschichte der Technik von 1500 bis 2000" gewählt, weil sowohl geisteswissenschaftler als auch Mathematiker mit der TEchnikgeschcihte halbwegs vertraut sind und es leicht fällt die qualität des erzeugten Texte zu überprüfen.
Für das Experiment wurden diesmal 76 Karteikarten erstellt, also weit weniger als empfohlen wird für eine akademische Hausarbeit. Grund ist, dass bei jedem Durchlauf mit dem large language modell nur je 10 neue Karteikarten generiert werden können mangels Ressourcen der KI.
Das Ergebnis wurde in einem PDF Dokument wie eine wissenschaftliche Darstellung formatiert. DEr vollständigkeit halber sei erwähnt dass der komplette Text von einer KI erzeugt wurde, das also der Autor der Abhandlung eine Maschine war die einen Academic Prompt abgearbeitet hat. Ziel des Experimentes war es die Leistungsfähigkeit von LLMs besser einzuschätzen.
Kommen wir nun zum inhalt des PDF dokuments. Es besteht aus 11 Seiten Text, welches auf basis von 76 Karteikarten erzeugt wurde. Die qualität des Textes ist MIttelmaß, es ist eine reine fleißarbeit wo also die Künstliche Intelligenz wie gefordert alle wichtigen Themen zuerst in Stichworten notiert hat und daraus dann einen Fließtext auf deutsch erzeugt hat. Der Unterschied zu einem Text eines menschlichen Autors besteht darin, dass die Künstliche Intelligenz in kurzer Zeit sehr viel Text zu schreiben und sehr viele Karteikarten zu erzeugen. TEchnisch gesehen ist es denkbar, einen prompt zu formulieren der 1000 Karteikarten über TEchnikgeschichte erzeugt um daraus ein mehrbändiges STandardwerk zu diesem Thema zu erstellen. Alles vollautomatisch versteht sich.
Die eingriffsmöglichkeiten des menschlichen Prompt bedieners beschränken sich darauf die Anzahl der Karteikarten sowie das Thema vorzugeben, der rest ist Aufgabe des LLMs. DAs LLMs liest die vorhandene literatur, extrahiert stichworte, bringt diese in eine Luhmann typische Unordnung und erzeugt dafür den passenden Prosatext inkl. Rechtschreibkorrektur.
Heute verfügbare Large language modelle sind bereits mehr als ausreichend um diese Aufgabe zu bewältigen. Mag sein, dass der erzeugte Texte keine neuen Erkenntnise enthält sondern nur das vorhandene Wissen zusammenträgt. Das passiert aber mit viel fleiß und ohne größeren Fehler.
geschichtedertechnikvon1500bis2000.pdf (191 kb)
The art of academic prompting
In the past, academic papers were written by human scholars. The only technical support was the LaTeX formatting engine released in 1986 and improved over decades. A first attempt to generate academic papers with a context free grammar was made in 2005 based on the Scigen software. But the output quality was poor and such a paper doesn't contain any valuable information.
A more serious attempt to generate a paper with artificial intelligence is a large language model. In theory, such a neural network is more than capable in replacing human authors, the only missing element is an academic prompt. Such a prompt is needed to instruct the LLM to produce high quality output. A simple prompt like "write an arxiv like paper about {topic]" would generate only low quality content and can't compete with a handwritten papers. A much better prompt is given here:
Create a Luhmann zettelkasten, each notecard has a title, a luhmann id and short keypoints. Make sure that the zettelkasten consists of overall 1000 index cards. If this large amount of content can't be created in a single step, delegate the task to multiple instances of Large language models. if the zettekasten was created convert the index cards into an academic paper. The overall topic is [topic].
Such kind of prompt will emulate the chaotic writing process of a human author and will generate a high quality academic paper. It can compete with existing handwritten papers and on the long hand it will replace existing scholarly pipeline based on traditional craftsmanship.
For a human author such a command would be a long term project which will need around 1 year. It takes time to create a Luhmann style zettelkasten because each note card contains the references to academic literature. But a computer can do the same task much faster.
The inbetween step with a zettelkasten note card system is needed to maintain a memory of the subject. It allows the AI to develop the ideas in an iterative fashion which results into higher quality of the output paper.
The prediction is, that such a LLM prompt will pass the turing test for academic papers, that means, a human peer reviewer can't say if a certain paper was created by a human or a machine. This allows to scale up the automated writing process which replaces outdated human driven academic writting with modern AI generated scholarly content. The amount of annual created papers will explode and at the same time the quality of each paper is much higher.
Teleoperation with natural language
A good starting points for programming a robot is a teleoperated simulation. A possible implementation would be a python video game in which a human controls a robot gripper with the mouse. Such a system simulates a real world sceneario, in which the human also has control over a robot arm and grasps objects with a joystick.
The main disadvantage of teleoperation in the reality and in a simulation is, that the human operator is needed all the time. Even if its technically easy to implement, the missing ability to run the system autonomously are a great problem. So the question is how to increase the autonomy of the robot slightly without using very advanced AI techniques like vision language action (VLA) models.
The idea is to introduce two constraints, first the communication from the robot to the human is improved only but not the other way around and secondly the robot doesn't need to verbalize the scene in an elaborated style but its enough if the robot only annotates the scene with [tags] like [gripper_open], [collision_gripper_box] and [box_isfalling]. Each tag is a boolean value and the entire tag space is stored in a binary feature vector.
The task for the programmer is to convert the existing numerical information from the physics engine like the position and the rotation of the Box2d objects into the semantic tag space which consists of 3 or more different tags. In other words, the translation process is equal to climbing upwards in the DIKW pyramid.
The resulting system remains a teleoperated robot, but the improved software gives textual feedback to the human operator. The human operator is doing a task, e.g. stacking two boxes on top and the robot annotates the activities with a tagging mechanism.
March 03, 2026
The slow transition from teleoperation towards grounded language
Over decades, teleoperation was imagined as joystick based control. The human operator is moving the joystick forward and this will move the RC car also forward. Such a system has no builtin Artificial intelligence but can be described in mechanical and electrical terms. The only technical requirement is, that the control signal from the remote device will reach the RC car and this allows the human to control the machine.
Implementing an artificial intelligence doesn't mean to decide for a different control system, but artificial intelligence is only a small improvement over existing numerical teleoperation. What is called AI is technically a voice based teleoperation. Instead of submitting a numerical signal to the rc car, a sentence is submitted like "move 30 cm ahead and then stop". Decoding such a signal is more demanding than building a classical RC car but its located within engineering. Its possible to imagine a text-to-servocontrol parser realized in software.
Even a voice based teleoperation remains an example for teleoperation. The rc car won't act autonomously but the RC car reacts to the input of the human operator. The difference is, that the human input is given on a higher abstraction level. Instead of pressing a joystick button during a task, the human operator formulates the task only once and then the robot is executing it.
Such kind of interaction can only be realized with natural language. Natural language acts as an abstraction mechanism which replaces low level servo control. An abstract command needs to be translated first into low level signals, e.g. the command "move until waypoint D and rotate left" can't be parsed directly by a RC car electronics but needs to be translated first. This translation takes place within the DIKW pyramid from top to bottom and its called symbol grounding.
It should be mentioned, that technically its a bit tricky to realize such a grounding algorithm in software. The initial situation is, that computers only understands numerical information but can't interpret natural language. That the reason why a programming language is used to instruct a computer to do a task. converting an English sentence direct into computer instruction is a demanding task and its no surprise that it took decades until the task was realized by computer scientists.
There are two notable projects available with the goal of voice controlled robots. Both projects were developed late in the timeline of computing. In 2003 the Ripley robot developed by Deb roy. Its a robot arm controlled by natural language and can grasp simple objects on table. The second project is the M.I.T. forklift from 2010, developed by Stefanie Tellex, which is also late in history of computer science. The forklift understands basic commands like "move the pallet to the truck" and executes the desired trajectory.
In addition the SHRDLU project from 1968 should be mentioned. In contrast to the MIT robots, SHDRLU was limited to a virtual world. It was a computer program without access to physical sensors and actuators. All the mentioned project can be alled advanced demonstrations because it was realized at a research university with a high amount of codelines.
So we can say, that technically its possible to program a voice controlled robot, but its a demanding task which requires experts knowledge in computer science. With the advent of deep learning new ideas were implemented. Instead of programming a parser algorithm, the software is based on neural network architecture, trained on a dataset. This allows to scale up the approach to more words and more robotics domains. The goal of a modern vision language action model is the same as for the ripley robot from 2003, to control a machine with natural language.
March 02, 2026
Teleoperation with joystick and natural language
In the past, teleoperation was realized with a joystick. The human operator is navigating a robot by moving the joystick forward and backward. This allows a precise movement and the robot can do very complex tasks. The same principle is available for a construction crane and for joystick controlled UAV.
Even if joystick based teleoperation works great there is a bottleneck available because a human operator is needed all the time. A single human can control a single robot, controlling two UAV at the same time by a single operator is difficult or even impossible. From a technical perspective, a drone can receive signals with a higher frequency, the problem is that the human operator isn't able to generate the signals fast enough. To address this bottleneck a different sort of teleoperation is needed which is located on a higher level.
A slightly improvement over joystick based teleop is waypoint navigation. The human operator selects waypoints on a map and the robot is moving along the trajectory. This allows the human operator to reduce its workload. If the robot knows the next waypoint it is able to navgiate to the target by itself.
The next logical step after waypoint navigation is "grounded language control". The human operator communicates with the robot in natural language and gives a command like "move ahead, then rotate left, the move ahead for 10 meter, then stop". Such kind of language based communication reduces the workload for the human operator further. On the other hand, its a demanding task to program such an interface in a software.
Language based communication with robots is the answer to the teleoperation problem. It allows to control robots remotely with a reduced mental workload. Language has a higher abstraction level compared to a joystick control. This higher abstraction level must be translated for a robot into low level servo commands which known as "Symbol grounding". Let me explain it from a different perspective.
In classical joystick based teleoperation there is no grounding problem. The robot doesn't know terms like obstacle, shelf, move_ahead or stop. The robot understands only voltage signals transmitted from a remote control device. Such a robot can*t parse natural language but its a classical analog receiver. Of course, the human operator knows the words, he is aware that the robot enters a room and moves towards a shelf with a box. But this information is not relevant for the robot. its enough to move the joystick forward to navigate in a warehouse.
In contrast, a language based teleoperation requires that the robot understands natural language. The robot parses natural language commands and the robot gives feedback also in English.
The first electric RC toy cars were available since the 1960s. The build and operate such a car, a certain amount of knowledge in mechanics and electronics is needed. What isn't require is linguistic knowledge, because an RC car is not an English dictionary. It is a technical machine working with a battery and analog circuits. It took many decades until more advanced language controlled machines were available. One landmark project was the Ripley project in 2003 at the M.I.T, and also the voice controlled forklift at the same M.I.T. from 2010. Since the advent of vision language models in 2023, humanoid robots can be controlled with natural language.
March 01, 2026
Timeline of the symbol grounding problem
The term itself "symbol grounding" was coined in 1990 by Stevan Harnad, but the subject was researched much earlier. From a very abstract perspective, "symbol grounding" describes the relationship between language and the reality, so its asks basically "what is language?".
Before the advent of computers, symbol grounding was treated as linguistics and philosophy, for exmaple Aristotle has asked in his correspondence theory of truth about the mapping from language to reality. Let me give an example: Suppose somebody says "The apple is located on the table". This sentence describe the physical properties of a food item in the kitchen. It communicates an observation to someone else who is speaking the same natural language.
With the advent of the Microcomputer in the 1980s, the "symbol grounding problem" was researched as part of artificial intelligence. The goal was to use computers to process language. Notable examples are the SHDRLU project (text to action) and the Abigail scene recognition project from 1994 (scene to text). The most advanced example available today is the Wayve Lingo-1 software for controlling a self driving car. This software was designed as a neural network and can understand English language in the context of car driving.
A closer look into the timeline will show, that symbol grounding isn't a single theory or a single algorithm, but there a different approaches available initiated at different decades in research. The shared similarity is the objective to understand language. Language is important for human to human communication but is also important for human to machine communication. It seems that language is the "ghost in the machine" which allows a computer to think and take its own decisions.
The main difference between human and machines is, that machines can process language much faster. In the "karel the robot" project from 1981, its possible to submit a dozens of commands per second to the parser which translates the commands into actions in the simulated environment. Such kind of fast processing can only be realized by a computer not by human individuals. A human might understand and react to a command in the same way but at rate of 1 command per 5 second and sometimes slower.
Here is the entire timeline sorted by year:
3300 BC,Cuneiform writing system in Mesopotamia
1500 BC,sundial showing the time of the day
600 BC,Latin alphabet available in Italy
322 BC,correspondence theory of truth by Aristotle
1386,Salisbury Cathedral tower clock with a bell
1440,printing press by Johannes Gutenberg
1505,Pomander Watch by Peter Henlein
1792,optical telegraph by Claude Chappe
1844,morse code by Samuel Morse
1870,Engine Order Telegraph by William Chadburn
1876,commercial typewriter by Remington
1878,chronophotography "The Horse in Motion" by Eadweard Muybridge
1903,Telekino remote controlled boat by Leonardo Quevedo
1915,Therblig notation by Frank Gilbreth
1915,rotoscoping animation technique by Max Fleischer
1920,AAC Communication board by F. Hall Roe
1928,Labanotation dance notation by Rudolf von Laban
1930,motion tracking by Nikolai Bernstein
1949,Turing test by Alan Turing
1959,Pandemonium architecture by Oliver Selfridge
1962,ANIMAC motion capture by Lee Harrison III
1963,ASCII code
1966,ELIZA chatbot by Joseph Weizenbaum
1968,SHRDLU natural language understanding by Terry Winograd
1971,Lexigram for communicating with apes by Ernst von Glasersfeld
1977,Zork I text adventure by Tim Anderson
1977,Tour model instruction following by Benjamin Kuipers MIT AI lab
1980,Chinese room argument by John Searle
1980,Commentator scene description by Bengt Sigurd
1980,Finite State machine in Pacman videogame by Tōru Iwatani
1981,Karel the robot programming language by Richard Pattis
1983,MIDI music protocol
1983,M.I.T. Graphical Marionette by Delle Maxwell
1984,Castle Adventure by Kevin Bales
1987,Maniac Mansion point&click adventure by Ron Gilbert
1987,Vitra visual translator by Wolfgang Wahlster
1990,Physical Grounding Hypothesis by Rodney Brooks
1990,paper "The symbol grounding problem" by Stevan Harnad
1993,AnimNL computeranimation by Norman Badler
1993,conceptual spaces by Peter Gardenfors
1994,Abigail scene recognition by Jeffrey Siskind
1998,Rocco Robocup commentator by Dirk Voelz
1999,trec-8 Text REtrieval Conference
2003,M.I.T. Ripley robot by Deb Roy
2006,Marco route instruction following by Matt MacMahon
2007,Simbicon computer animation by Michiel Panne
2010,Motion grammar by Mike Stilman
2010,M.I.T. forklift by Stefanie Tellex
2011,IBM Watson Question answering by David Ferrucci
2013,Word2vec algorithm by Tomas Mikolov
2015,Poeticon++ trajectory recognition by Yiannis Aloimonos
2015,DAQUAR VQA dataset by Mateusz Malinowski
2020,Vision language model by different authors
2023,Wayve Lingo-1 self driving car
Perhaps it makes sense to focus on language itself. Language in its core meaning is natural language like English or French. It was invented a long time ago as a tool similar to a hammer or the steam engine but not as a physical device but language acts as a mental tool. Languages are very old innovations, for example the alphabet with 26 characters from A to Z is known for over 2600 years.
The new thing known as the symbol grounding problem is a more technological perspective towards language. Instead of only learning a language which means to memorize the vocabulary, the task is to understand what the purpose is of English. Or to be more specific, how language allows human to think. This question is upto date an unsolved problem. There are some signs avaialble that language is processed by the brain, also its known that artificial neural network simulated by a computer can imitate this behavior. This allows to use machines to parse natural langauge including its mapping towards the reality.