RAP Lab · Research on Artificial Persons
The Complete Furhat Guide
From signing up for the SDK to holding an AI-powered conversation — every step, with the actual screenshots from the setup.
From signing up for the SDK to holding an AI-powered conversation — every step, with the actual screenshots from the setup.
Furhat is a physical social-robot head. It has microphones (it hears), speakers (it talks), a camera (it sees), and a projected animated face — so it can smile, blink, raise eyebrows, and move its mouth in sync with speech.
Every conversation with Furhat follows the same physical chain. Click each step to see what happens:
Because the face, voice, gaze, and dialogue are all software-controlled, you can change exactly one thing at a time — the smile, the voice pitch, where it looks — while everything else stays identical. That makes Furhat ideal for controlled experiments on trust, emotion, attention, tutoring, and human-robot interaction.
Furhat vs. the Unitree R1: Furhat gives you precise control of face and voice; the R1 gives you a full moving body. For Chinonso’s research, Furhat is the tool for face/voice manipulation studies, the R1 for embodiment studies.
1Sign up. The journey starts at furhatrobotics.com/furhat-sdk. After signing up you get a welcome email from the Furhat Team:
2Wait for the Developer Zone invite. Check inbox and spam. The invite contains the activation link that creates your account password.
3Log in. The email links to furhat.io/login — “Log in to the Furhat Developer Zone”:
4Download the launcher. Inside the Developer Zone, the Downloads page offers the SDK Desktop Launcher for all three systems:
1Run the installer. Double-click the downloaded furhat-sdk-desktop-launcher-Setup.exe and follow the prompts.
2Get your API token. The launcher’s first screen asks for a Furhat API token:
To get the token: in your browser go to furhat.io/profile/user, log in, scroll to “Furhat API token”, and click Create API-key:
3Paste the token into the launcher (Figure 3) and click the arrow. Your account is now linked.
4Install the Virtual Furhat. The welcome screen offers Virtual Furhat 2.9.3 — click Install and wait a few minutes:
5The launcher is running. You now see the full menu — Create skill, Start Skill, Open web interface, AI Creator, Remote API, Blockly:
1Open the web interface. In the launcher click Open web interface. Your browser opens at localhost:8080 asking for a password:
2Meet your robot. The Home page is a remote control for the virtual robot — no coding needed:
3Verify the install — the two tests.
If both work, the SDK is fully installed. (If anything looks wrong, the launcher’s view console shows the error log.)
Furhat’s SDK page lists the toolkit. Here is what each piece means for a researcher:
Yes — the robot can hold open-ended AI conversations. The design: Furhat listens, sends your words plus the conversation history to OpenAI’s chat API, and speaks GPT’s reply. Based on Furhat’s official OpenAI tutorial (verified September 2026).
Go to platform.openai.com, sign up/log in, create a secret key under API keys, and copy it immediately — it is shown only once.
In the Furhat Studio launcher click Create Skill Project, choose a folder, name it OpenAISkill.
Install the free Community edition from jetbrains.com/idea. Open the OpenAISkill folder as a project and let the Gradle sync finish.
Open build.gradle, add this line in the dependencies section, then press the Gradle reload button:
implementation 'io.github.sashirestela:simple-openai:3.8.2'A new file in the source folder — the utility function that talks to GPT, feeding it the system prompt plus the last 10 conversation turns:
import furhatos.flow.kotlin.DialogHistory
import furhatos.flow.kotlin.Furhat
import io.github.sashirestela.openai.SimpleOpenAI
import io.github.sashirestela.openai.domain.chat.ChatMessage
import io.github.sashirestela.openai.domain.chat.ChatRequest
/** API key read from environment — never hard-coded in source **/
val serviceKey = System.getenv("OPENAI_API_KEY") ?: "YOUR_API_KEY"
val systemPrompt = "You are chatty robot. You should speak in a conversational style. Never say more than two sentences."
val openAI = SimpleOpenAI.builder()
.apiKey(serviceKey)
.build();
fun getDialogCompletion(): String? {
val chatRequestBuilder = ChatRequest.builder()
.model("gpt-4o-mini")
.message(ChatMessage.SystemMessage.of(systemPrompt))
Furhat.dialogHistory.all.takeLast(10).forEach {
when (it) {
is DialogHistory.ResponseItem -> {
chatRequestBuilder.message(ChatMessage.UserMessage.of(it.response.text))
}
is DialogHistory.UtteranceItem -> {
chatRequestBuilder.message(ChatMessage.AssistantMessage.of(it.toText()))
}
}
}
var futureChat = openAI.chatCompletions().create(chatRequestBuilder.build())
var chatResponse = futureChat.join()
return chatResponse.firstContent().toString()
}Replace the Greeting state (the main state in the blank template):
val Greeting: State = state(Parent) {
onEntry {
furhat.ask("Hi there")
}
onResponse<Goodbye> {
furhat.say("Goodbye")
goto(Idle)
}
onResponse {
val robotResponse = call {
getDialogCompletion()
} as String?
furhat.ask(robotResponse?:"Could you please repeat that")
}
onNoResponse {
furhat.ask("Sorry, I didn't hear anything")
}
}The call {...} wrapper keeps the robot responsive during the seconds GPT takes to answer. Specific intent handlers (like Goodbye) must sit above the generic onResponse.
In IntelliJ: Run → Edit Configurations → Environment variables → add OPENAI_API_KEY with your key as the value.
Run main.kt, then speak to the robot — it answers with GPT-generated speech. Say “goodbye” and the scripted farewell fires instead. That is the hybrid design: fixed script where you need experimental control, AI where you want open conversation.
GPT takes a few seconds. Without a filler, the silence confuses people — so the robot looks away and says “Let me think” while waiting. Add this at the top of onResponse, before the call:
furhat.say(async = true) {
+Gestures.GazeAway
random {
+"Let's see"
+"Let me think"
+"Wait a second"
}
}Status (September 2026): the lab’s physical Furhat is on order and expected within a week or two. Everything in this guide was built on the Virtual Furhat — deliberately.
Why that’s fine: the virtual and physical robots run the same system. A skill you build and test today runs on the real head unchanged — you only change where it points:
Everything in this guide, as clickable checkboxes. Your progress is saved in this browser.
All screenshots are from Chinonso’s own setup session, September 19, 2026. SDK version at time of writing: Virtual Furhat 2.9.3, simple-openai 3.8.2, model gpt-4o-mini.