DifrasAI: AI Research Company

02 · Architecture

Technical blueprint

Lightweight modular Vision-Language-Action stack. Key principle: modularity + persistent world state. Components are specialized, loosely coupled, and communicate primarily through the World Model.

High-level data flow

User Instruction → Language Reasoner → Task Planner → World Model
Vision Encoder + Sensors → Scene Encoder → World Model
World Model + Subtask → Action Policy → Motion Controller → Robot
Sensors + Vision feedback → World Model

Modules

Module	Role
`schemas`	World / task / action models
`vision · scene · world`	Perceive + persistent state
`language · planner`	Intent + subtasks
`policy · control · robots`	Act + safety + adapters
`loop · factory`	Wire + run
`ui · demos · bench`	CLI + demos + benchmarks

Design principles

World Model is the integration bus
Language never emits joint commands
Safety lives in the motion controller
LLM / planner run on events, not every tick

Core components

Vision Encoder

kinetic.vision

Compact visual features from RGB (optional depth). Default: MockVisionEncoder (block pooling + change detection). Production targets: FastViT, MobileViT, EfficientViT, DINOv2/v3 Tiny, SigLIP.

Scene Encoder

kinetic.scene

Structured symbolic scene, detections, 6D poses, attributes, scene graph edges, not raw tokens for the LLM. Default: MockSceneEncoder + rule-based build_scene_graph.

World Model

kinetic.world

Central persistent memory: objects, robot proprioception, scene graph, task progress, short/long-term memory. Event-driven, delta-aware updates; optional SQLite persistence; compact summary_for_llm().

Language Reasoner

kinetic.language

Pure intent, no action generation. Input: user command + world summary → GoalSpec. Default RuleBasedReasoner; BitNetReasoner via bitnet.cpp; optional HttpLLMReasoner. Event-only, never inside the control cycle.

Task Planner

kinetic.planner

Hierarchical decomposition: Goal → ordered Subtask list with pre/postconditions. Default HierarchicalPlanner (fetch / place / navigate templates).

Action Policy

kinetic.policy

World state + current subtask → ActionCommand (EE pose, joints, gripper, stop). Default HeuristicPolicy; production path: Diffusion Policy / small transformer / BC.

Motion Controller

kinetic.control

Safety filter, rate limits, joint clamps, pseudo-IK trajectory. Production: MoveIt / full IK, collision checking, force limits.

Robot Adapter

kinetic.robots

Generic trajectory → robot API. Default MockSimRobot; adapters for ROS2, Franka, UR5 and more via robots.base.RobotAdapter.

Event-driven loop kinetic.loop

Efficiency: planner/LLM not every frame; only changed objects matter.

New instruction or sensor tick
Vision → Scene → World Model (delta)
If task-relevant: Reasoner + Planner
Policy selects primitive
Controller → Robot
Feedback → World Model
Repeat

System diagram

                 User Instruction
                        │
                        ▼
               Language Reasoner
                        │ Goal
                        ▼
                  Task Planner
                        │ Subtasks
                        ▼
 ┌────────────── World Model ◄──────── feedback ──────────┐
 │                     │                                    │
 │            Vision + Scene Encoder                        │
 │                     │                                    │
 │              Action Policy                               │
 │                     │                                    │
 │            Motion Controller                             │
 │                     │                                    │
 └──────────────────► Robot ────────────────────────────────┘

This page is the architecture reference for Kinetic on the DifrasAI site.

Kinetic docs