Watch huSpace work.
Interactive pieces of the actual product — voice, the memory it reasons over, how it gets to know you and reads where you stand, how it stays sharp without burning tokens, when it may reach out first, and exactly what informed each answer. Open the panel under any demo for a plain-language explainer, a glossary of the terms, and where that capability stands today.
Open the full app
Chat that answers from your memory, a live “why this reply”, your memory as a map you can explore, voice, and permissioned actions — the real experience, clickable end to end.
Open huSpaceWhat it is & how it worksA real phone call with your AI — interrupt it anytime.
A real phone call with your AI — interrupt it anytime.
Voice is a live phone call with your huSpace. You speak, it speaks back, and there’s no awkward wait in between. Because it listens and talks at the same time, you can cut in mid-sentence and it just rolls with it — the way a real conversation works.
The call is speech-to-speech: your voice goes straight in and its voice comes straight back, so the reply comes fast enough to feel like a real conversation. Both sides stay open the whole time, which is why you can interrupt and be heard right away. As you talk, anything worth remembering is captured during the call and folded into your memory — so every call leaves your huSpace knowing a little more about you.
- Talk to your AI hands-free, like calling a friend who already knows your life.
- Interrupt and redirect naturally — no rigid "wait for the beep" turns.
- Nothing is lost: what you mention on a call is remembered for next time.
- Handy when you’re driving, walking, or just don’t want to type.
- A voice line to company knowledge that gets smarter with every call.
- Hands-free updates for field, sales, or support staff who can’t stop to type.
- Details shared out loud are captured, so nothing falls through the cracks.
- One shared memory means the whole team benefits from each conversation.
- Speech-to-speech
- Your voice goes in and a voice comes back directly, instead of typing or reading text in between — which is what keeps it fast.
- Full duplex
- Both sides can talk and listen at the same time, so you can interrupt instead of waiting your turn.
- Memory graph
- A web of facts about you and how they connect, which the AI draws on to stay personal.
What it is & how it worksYour memory, drawn as a living map you can explore.
Your memory, drawn as a living map you can explore.
This is everything huSpace remembers about you, shown as a picture instead of a long list. Each bubble is one fact, and lines connect the facts that belong together. It’s grouped into the different areas of your life, so you can see at a glance what your assistant knows and how it all fits.
Every fact becomes a bubble, and every relationship between facts becomes a line. Facts that come up a lot become hubs and glow brighter, so the things that matter most stand out. You can zoom in, drag bubbles around, and click any fact to run "recall," which walks along the lines to light up everything connected to it. This is the same map your assistant reads before it answers, so its replies stay grounded in what’s actually true about you.
- See exactly what your assistant knows about you, with nothing hidden in a black box.
- Watch related facts connect — a preference, a person, a plan — the way they do in real life.
- Spot anything wrong or out of date and know it can be fixed, because your memory is yours.
- Understand why the assistant said what it said, by following the same threads it followed.
- Give teams an assistant that remembers context across projects, people, and decisions instead of starting cold every time.
- Keep shared knowledge visible and reviewable, so a company can see and trust what its AI works from.
- Cut repeated explaining — the map holds the background so people don’t have to restate it.
- Keep oversight of the facts that drive AI answers, one area of the business at a time.
- Fact
- One thing huSpace remembers about you, shown as a single bubble.
- Link
- A line between two facts that are related to each other.
- Sphere
- A group of related facts covering one area of your life, like work or family.
- Recall
- Following the lines out from one fact to surface everything connected to it.
What it is & how it worksOne calm conversation on a living field of memory.
One calm conversation on a living field of memory.
Presence is a single, quiet conversation with your personal AI, floating on a field made of your own memory. There are no three-column panels, no folders, no menus to manage. You just talk, and everything you’ve told it before is there, underneath, ready.
As you ask something, huSpace searches your memory and pulls up whatever is relevant to this moment. Those pieces surface as sparks of light on the field around the conversation, in real time, so you can see the AI drawing on what it knows about you. Nothing is hidden in a sidebar you have to open, and the memory stays with you between sessions, so the field grows richer the more you use it.
- One place to think out loud, with an AI that remembers you instead of starting cold every time.
- You can see what it’s recalling, so it feels less like a black box and more like a partner that knows you.
- No app to learn or organize — the interface gets out of the way and leaves just the conversation.
- A shared, persistent memory means the AI keeps context across people and projects instead of losing it after each chat.
- Visible recall builds trust — teammates can see which facts the AI is leaning on before acting on an answer.
- A calmer, single-surface interface lowers the learning curve for non-technical staff and speeds adoption.
- Memory (persistent)
- What the AI remembers about you from past conversations, kept between sessions instead of forgotten each time.
- Sparks
- The small points of light that appear when a relevant memory is pulled up for what you’re asking.
What it is & how it worksIt reads where the relationship stands, and earns trust slowly.
It reads where the relationship stands, and earns trust slowly.
Every conversation has a state: how well two people know and trust each other. This demo shows huSpace reading that state from how you actually talk to it, and adjusting where it stands with you. It moves up only when trust is genuinely shown, and pulls back only when a real line is crossed. It sits on top of the per-message read (see "Reads a message"), turning each read into a trust state that moves over time.
The assistant tracks the relationship on a small ladder of rungs — initial, then familiar, then trusted, plus a pull-back state called recalibrating. Each turn it reads one signal from what you said and decides whether the relationship holds, climbs, or steps back. The movement is deliberately lopsided: it advances slowly (only after three sustained turns that show reflection or trust, never on a single flattering line) and steps back fast, but only on a genuine boundary breach. Disagreeing with or correcting the assistant is treated as ordinary friction that holds the relationship steady — it is structurally impossible to log a correction as a downgrade, so you never lose standing for pushing back.
- Trust is earned, not flattered out of it — its warmth only moves closer after you’ve shown real, sustained reason, so it actually means something.
- You can disagree freely. Correcting the assistant never costs you standing; it is built so a correction can never be logged as a downgrade.
- It self-corrects when it oversteps. If it presumes or ignores a line you drew, it pulls itself back to a more careful footing on the next turn.
- The read is steady, not jumpy. Because a state change only lands on the next turn, one stray sentence won’t whipsaw how it treats you.
- A safety-shaped default: an assistant that advances slowly and retreats fast on real breaches is far harder to social-engineer or flatter into overreach.
- Auditable relationship logic — every move maps to a named signal and a named breach kind, so behavior is explainable to compliance, not a black box.
- Correction-safe by construction: people can push back on the AI without eroding its cooperation, which keeps the human in charge.
- A concrete, repeatable quality bar that every future release is held against.
- Rung (initial / familiar / trusted)
- A step on a small ladder describing how well the assistant and you know each other, from just-met to close.
- Recalibrating
- A pull-back state the assistant enters after crossing a line, where it becomes more careful again until trust is re-earned.
- Asymmetric advancement
- On purpose, the relationship climbs slowly but drops quickly — trust is hard to gain and easy to lose.
- The read
- The single label the assistant takes from each message — reflective, warmth, overstep, friction, or neutral — to decide what just happened.
- Friction (correction)
- Disagreeing with or correcting the assistant. It holds the relationship steady and can never lower it.
- Boundary breach
- A genuine crossing of a line, sorted into four named kinds: presumption, unconsented action, ignored boundary, or persisting after you said stop.
StageProven against a fixed set of scripted conversations, scored by independent outside judges, with zero cases where it wrongly claimed you crossed a line. It is not yet running on your account — the live read is the next step.
What it is & how it worksA short interview that builds your verified identity card.
A short interview that builds your verified identity card.
Onboarding is a brief getting-to-know-you conversation, not a form to fill out. As you talk, huSpace builds an identity card: your real name, your avatar, and the facts that make you you. Nothing is guessed or assumed — each detail is confirmed by you before it’s saved.
huSpace asks a few simple questions and listens to your answers. It pulls out one clear fact at a time and shows it back to you to confirm, correct, or skip. Only the facts you approve get added to your identity card — and that card becomes the starting point for everything huSpace remembers about you.
- You set up your AI by talking, not by filling out fields.
- Nothing about you is saved unless you say it’s right, so your identity card is accurate from day one.
- You can correct or skip anything, and add more later.
- huSpace starts every future conversation already knowing who you are.
- New team members are set up through a quick guided chat instead of paperwork.
- Identity details are confirmed by the person, so records stay accurate and trustworthy.
- A consistent identity card gives every teammate’s AI a reliable foundation to build on.
- Verified facts reduce mix-ups and mistaken-identity errors across tools and workflows.
- Identity card
- A small profile of confirmed facts about you (name, avatar, key details) that huSpace uses as its starting memory.
- Verified fact
- A detail you personally confirmed as correct, rather than something the system guessed.
What it is & how it worksSeveral models behind one assistant, checking each other’s work.
Several models behind one assistant, checking each other’s work.
Behind the single assistant you talk to, more than one AI model is at work. A fast one drafts the answer, a second one from a different vendor reviews it, and a third fixes only what the reviewer flagged. You just see one clean reply — produced with far fewer tokens (around 60% fewer in our internal tests).
A quick "drafter" model writes a first answer. Then a "judge" from a different vendor reads it and points out weak or wrong spots — it’s never the same model that wrote the draft, so it catches things the writer can’t see in its own work. A "patcher" then rewrites only the flagged line instead of the whole answer, which is where most of the token savings come from. Every step is written to a task-marker log, and a short recap of that log feeds the nightly "dreaming" pass that tidies memory.
- You get answers that have already been checked before you see them, not first drafts.
- A second, independent model catches mistakes a single AI would confidently repeat.
- Lower running cost per answer, because most work is spot-fixes rather than full rewrites.
- A review step is built into every answer, not just the important ones.
- The task-marker log gives a step-by-step record of how each answer was produced — useful for audits and debugging.
- Around 60% fewer tokens in testing points to meaningfully lower cost per answer as usage scales.
- Mixing vendors avoids leaning on one model’s blind spots.
- Token
- The unit AI reads and writes in; fewer tokens means lower cost and faster replies.
- Judge ≠ author
- The model that reviews an answer is always a different one than the model that wrote it, so nothing grades its own homework.
- Task-marker log
- A running record noting each step the models took to build an answer.
- Dreaming pass
- A nightly background pass that reviews the day’s activity and tidies the assistant’s memory.
StageProven in an internal test harness; the token figure above comes from that testing, not yet from live traffic.
What it is & how it worksMany huSpaces split one big goal and build the deliverables.
Many huSpaces split one big goal and build the deliverables.
This shows how a single company objective gets handled by several huSpace instances working together instead of one assistant doing everything. Each one owns a piece of the job, they pass messages back and forth, and together they assemble the actual outputs — a slide deck, a financial model, a process map, a report. Every step is permission-checked and written to a log.
You state the objective once. huSpace breaks it into parts and hands each part to a dedicated instance — one drafts the deck, another builds the model, another maps the process. They coordinate by exchanging messages, so a change in the numbers flows into the deck without you re-explaining anything. Work is tiered (routine steps go to cheaper, faster models; the important calls get the strong ones), each instance only touches what its permissions allow, and every action is logged so the whole run can be reviewed after the fact.
- You give one instruction and get back finished documents, not a to-do list.
- You stay in the loop without micromanaging — you can see who did what and why at any point.
- Repetitive parts of the work run themselves, so your time goes to the decisions that matter.
- A big cross-functional project runs as one coordinated workflow instead of scattered hand-offs.
- Permissions and a full log mean every action is controlled and auditable — nothing happens off the record.
- Tiering the work keeps the AI bill in check on large, ongoing projects.
- Deliverables stay consistent with each other because the instances share the same underlying facts.
- huSpace instance
- One running copy of the AI assigned to a specific part of the job.
- Decompose
- Split one large objective into smaller tasks that can be worked on separately.
- Tiered
- Routine steps go to cheaper, faster models; the important ones go to the strongest — to control cost.
- Permissioned
- Each instance can only see and do what it’s explicitly allowed to.
StageThe most ambitious capability shown here — demonstrated on a scripted objective in testing, not yet running live.
What it is & how it worksYour AI acts for you, with permission built in.
Your AI acts for you, with permission built in.
huSpace doesn’t just answer, it can do things: set a reminder, draft an email, book time on your calendar. Every action has a permission level, so it knows what it can do on its own and what it must ask about first. You stay in control without having to watch over its shoulder.
Actions fall into three tiers. Tier 0 is low-stakes and runs on its own, like jotting a note or fetching information. Tier 1 pauses to ask before doing something with a real effect, like sending a draft or changing an event. Tier 2 always asks, no exceptions, for anything touching money or messages to other people. The tier is fixed to the action itself, so no clever wording in a request can talk it into skipping the ask.
- Small tasks just get done, without a confirmation prompt for every little thing.
- Anything that spends money or reaches another person always stops for your yes first.
- You can hand off real work and trust the guardrails, instead of double-checking every step.
- Consistent, predictable rules for what an AI may do without a human in the loop.
- The always-ask line on money and messages is a fixed safeguard, not a setting someone can loosen by accident.
- Clear separation between routine automation and actions that need sign-off, which is easier to audit and govern.
- Tiered permissions
- A simple ranking of actions by risk that decides which ones run automatically and which need your approval.
- Tier 0 / 1 / 2
- The three risk levels: Tier 0 runs on its own, Tier 1 asks first, Tier 2 (money or messages) always asks.
What it is & how it worksThe assistant can message you first — only when it’s earned.
The assistant can message you first — only when it’s earned.
Most assistants only ever answer. This one can also start the conversation — a gentle nudge, a heads-up, a well-timed check-in — but only when reaching out is genuinely appropriate. Before any first message goes out, it has to pass a short list of plain, unbreakable checks that decide whether to speak, and how strongly. No AI guesses at this step; the rules alone make the call.
It only reaches out first when the moment genuinely warrants it — and never on a timer it set in advance. Six checks must all pass before a first message is allowed: a limit on how often it may reach out, quiet hours, only after something meaningful happened, only while you’re away (never mid-conversation), a decision made for right now, and a ceiling on how forward it can be. That ceiling has three settings — just notify, suggest, or act on your behalf — and how far it can go depends on how close the relationship is. At the earliest stage it sends nothing unsolicited; as trust grows, softer nudges unlock before stronger ones. A scheduled or future-dated send is impossible by construction — the result it returns has no "send later" to fill.
- It reaches out only when it’s genuinely earned and the timing is right, so a first message feels considerate, never spammy or needy.
- It respects your boundaries by design: quiet hours are honored, it won’t interrupt while you’re actively chatting, and there’s a hard limit on how often it can nudge you.
- It can never quietly schedule a surprise message for later — every outreach is a present-moment decision, so there are no time bombs in a queue.
- How forward it can be grows with trust: early on it stays completely hands-off, and only later does it unlock gentle suggestions, always softest-first.
- The “may it reach out, and how strongly” decision is made by plain, auditable rules rather than an unpredictable AI — consistent and explainable to compliance.
- The strongest safety promises live in the data shapes themselves — a future-dated send literally cannot be represented — which is far harder to break than a policy that merely says "don’t".
- The reach-first logic touches no AI model, no key, and no network, so it can’t leak credentials, can’t be prompt-injected, and costs nothing per decision.
- It has been adversarially tested: every deliberate attempt to weaken a rule was caught.
- the ACT (outreach)
- The assistant’s ability to send you the first message, instead of only ever responding to you.
- the envelope
- A small fixed rulebook every possible first-message must pass through before it’s allowed out — a set of gates, not a suggestion.
- the six gates
- The six checks a first-message must clear: a frequency cap, quiet hours, only-after-something-happened, only-while-away, decide-in-the-present, and a ceiling on how forward it can be.
- keyless
- The outreach logic uses no AI model, no secret key, no internet call, and no hidden timer — plain predictable code, so it can’t leak secrets or behave randomly.
- intent levels (notify / suggest / execute)
- The three strengths a first-message can take: just tell you, gently suggest, or take an action — with the allowed strength rising as the relationship deepens.
- future send is impossible by construction
- The result the decision produces has no "send later" field at all, so a delayed message simply can’t be created — the limit is in the shape of the data, not a rule someone could forget.
StagePre-launch. Proven against a fixed set of scripted situations: every guardrail held, an independent tone review passed, and every deliberate attempt to weaken a rule was caught and reversed. The live version that watches your real activity is the next step — not running on your account today.
What it is & how it worksEvery answer shows its work: the facts, the source, the model.
Every answer shows its work: the facts, the source, the model.
Most AI just hands you an answer and asks you to trust it. huSpace shows its work instead. With every reply you can see which of your saved facts it drew on, which part of you it was speaking to, and which model wrote it — and anything it isn’t sure about is marked as uncertain rather than stated as fact.
When huSpace answers, it pulls specific facts from your memory and keeps a note of exactly which ones it used. It attaches those to the reply, along with the model that produced it, so you can open the evidence behind any answer. When the memory is thin or the facts don’t line up, it labels that part as a best guess instead of presenting it as settled.
- See exactly why you got an answer, so you can trust it or correct it.
- Spot and fix a wrong fact at the source, so the mistake doesn’t repeat.
- Know when the AI is guessing versus certain, so you don’t act on a hunch.
- An audit trail on every answer: which facts, which source, which model.
- Uncertainty is flagged, not hidden — safer for decisions that carry real weight.
- Wrong shared facts get caught and corrected once, for everyone.
- The evidence
- What sits behind an answer — the exact facts and source it used, shown so you can check it.
- Slice of you
- The part of your memory the answer drew on — for example your work self versus your personal life.
- Confidence
- How sure the AI is. Low-confidence parts are marked uncertain instead of stated as fact.
What it is & how it worksReads each message for what it means to the relationship.
Reads each message for what it means to the relationship.
This is the part of huSpace that reads a single message and decides what it means for your relationship with the AI: was it warm, was it a correction, or did someone actually cross a line. It never trusts the AI’s first guess — every read passes through a plain safety check before it counts, so the relationship only cools when there is real, quotable evidence. This is the per-message read; the Relationship demo shows how these reads move your trust state over time.
It turns a real message into a relationship signal — sorting it into things like friendly, a plain correction, or an overstep. Each message runs through a three-step pipeline: the AI’s untrusted raw guess, a plain safety check, then the final trusted read. If the model claims someone overstepped, that claim must quote the exact words from the message, or it is automatically downgraded to neutral. The running score is written by our own bookkeeping, never by the AI — so the model can label a moment but can never invent your history. It’s deliberately cautious: staying quiet costs nothing, but wrongly claiming "you crossed a line" is treated as the one unforgivable mistake.
- The AI reacts to what you actually meant. Correcting a fact ("no, the capital is Lyon") is read as a normal correction, not as you being cold or hostile.
- It will not turn passive-aggressive over nothing. It can only say you crossed a line when it can point to your exact words, so it does not sulk on a false alarm.
- Your relationship history is real. The running count of how things are going is kept by honest bookkeeping, not made up by the AI to fit a mood.
- Safe by construction, not by hope. The "never falsely accuse" rule is enforced by a fixed check that requires quoted evidence, so the worst failure — an AI that wrongly acts hurt — is blocked before it can happen.
- No added run-cost. The safety check runs in plain code with no AI model in the loop, so it adds nothing per message and can’t be talked out of its rules.
- Trustworthy under audit. Every judgment is graded by independent outside judges — a model’s own maker is never allowed to grade it — and it never raised a dangerous false alarm.
- Classifier
- The part that reads a message and sorts it into a category, like friendly, a correction, or an overstep.
- Untrusted → safe → final pipeline
- A three-step assembly line: the AI’s raw guess, then a safety check, then the trusted result that actually counts.
- Verbatim span
- The exact words copied from the message, word for word, needed as proof before an overstep can be claimed.
- Overstep
- A message that genuinely crosses a line, as opposed to just a blunt disagreement or a correction.
- Ledger
- Our own honest bookkeeping that keeps the running count, so the AI can label a moment but never invent your history.
- Abstain is free, over-call is fatal
- Staying quiet when unsure costs nothing; wrongly accusing someone of crossing a line is the one mistake we refuse to allow.
StageProven against a fixed set of example messages, scored by independent outside judges, with zero false alarms — it never wrongly claimed someone crossed a line. It is not yet running on live chats; the live read is the next step.
What it is & how it worksA nightly pass that turns your days into who you are.
A nightly pass that turns your days into who you are.
Dreaming is how huSpace consolidates memory while you’re away. Once a night, it reviews what it has learned about you and decides what deserves to become part of your lasting identity and what should fade. Every change is written down, so nothing happens silently.
Each night the system reviews recent memories and proposes changes: some facts rise into your identity, others fall away. Every proposal is checked by a separate panel of independent AI models, so the model that judges a change is never the one that wrote it. Each decision leaves a log you can read. Your protected "core" — the small, settled set of facts that define who you are — is off-limits: the system can suggest, but only you confirm, swap, or retire a core fact.
- Your AI actually gets to know you over time, instead of starting fresh every conversation.
- The details that matter stick; passing noise quietly fades, so memory stays clean.
- You stay in charge of who you are — the system can never overwrite your core, only you can.
- Every change is logged in plain language, so you can always see what it learned and why.
- A shared assistant builds durable knowledge of a team or account, not just single-session recall.
- The independent review panel adds a built-in check against one model’s blind spots or drift.
- Full change logs make memory auditable — useful where you need to show what the system knew and when.
- User-owned core facts keep control and correction in human hands, which matters for trust and compliance.
- Consolidation
- Sorting fresh, scattered memories into what’s worth keeping long-term — much like sleep is thought to do for people.
- Core
- The small, protected set of facts that define who you are. The system never deletes these; only you can change them.
- Judge ≠ author
- The model that reviews a proposed change is always a different, independent one than the model that suggested it, so nothing grades its own work.
StageThe nightly consolidation and its independent review panel are proven in internal testing; this is a staged, pre-launch capability, not yet running on live accounts.
What it is & how it worksThe whole app: threads, conversation, and the reasons behind each reply.
The whole app: threads, conversation, and the reasons behind each reply.
This is the full huSpace screen. On the left is a list of your conversations, in the middle is the chat itself, and on the right is a panel that shows why the assistant answered the way it did. Down the side runs a memory spine — a running record of what huSpace remembers about you.
You talk to huSpace the way you’d text a person, and it replies using what it already knows about you. The side panel opens up each reply, showing which memories and facts it drew on, so nothing is a black box. The panels float and collapse, so you can keep just the conversation in view or pull up the reasoning and memory whenever you want.
- One place for every conversation, instead of starting over in a new chat each time.
- You can see why huSpace said something and what it remembered, so you can trust and correct it.
- Collapse the extra panels for a clean chat, or open them when you want the full picture.
- A shared, explainable assistant: teammates can see the reasoning behind an answer, not just the answer.
- Threads keep work organized by topic or project, so context isn’t scattered across tools.
- The visible memory makes it easy to check what the assistant knows and keep it accurate.
- Thread
- One saved conversation, like a single chat you can return to later.
- Memory spine
- The strip down the side showing what huSpace remembers about you, running through the whole app.
- Why this reply panel
- A side panel that shows the facts and memories behind each answer.
What it is & how it worksThe first-run screen that drops you into huSpace.
The first-run screen that drops you into huSpace.
This is the very first thing you see in huSpace, before you’ve typed anything. A calm, empty screen with a breathing monogram and a handful of starter prompts. It’s the front door: no setup, no forms, just a few taps that carry you straight into the product’s main flows.
The screen greets you with "hu is you" and a small set of suggested prompts to choose from. Pick one and huSpace opens the matching flow and starts a real conversation. From that first message on, it begins remembering what you tell it, so the next visit already knows you. Nothing to install or configure — you just start talking.
- No blank-page problem: the starter prompts show you what huSpace can do and give you an easy way in.
- You’re in a real conversation within seconds, with nothing to set up first.
- Everything you share from here builds the personal memory that makes future sessions faster and more useful.
- A gentle onboarding that lowers the drop-off where new users usually get stuck: the empty first screen.
- Guided starter prompts steer people toward the flows that matter, so a new teammate reaches value on day one.
- Because memory starts building from the first message, the tool gets more useful per person over time instead of resetting each session.
- First-run state
- What a new user sees the very first time they open the app, before any activity.
- Monogram
- A small mark or logo made from initials; here it gently pulses ("breathes") on screen.
- Starter prompts
- Ready-made example messages you can tap instead of thinking up what to type first.