Give a robot a goal. It learns the rest.

Hephorvis is a self-improving agent system. It experiments, learns from every failure, and keeps each verified skill.

Watch the demo How it works
Goal
Exploring 0% task success

newest skill versionearlier versions, still in usenot learned yet

Skill library
    1. You give the goalTask, environment and limits. Nothing else.
    2. Agents learn itExperiment, diagnose, improve, verify.
    3. The robot keeps itEvery verified skill makes the next task easier.

    Watch a robot teach itself a task, then a harder one.

    The robot gets a goal and its limits. Agents run experiments, diagnose every failure, improve how they search, and verify the skill before keeping it. Task 2 is harder: two arms, a 9 mm hex and a keyed slot, and a skill the robot does not have yet.

    Goal

    Pick up the thread, wherever it lands on the table, and pass it through the ring.

    • Bounded workspace
    • No force on the ring
    • Frozen evaluator
    Task received Reading the goal and the limits
    15× speed
    Rollouts00
    Recent outcomes
    Skill library
    Skills upgraded: pick-up v4, insert v3 New versions for thin parts and tight clearances. Older versions stay for other tasks.

    Discovery trees

    Waiting for the first rollout

    Score
    Tested on
    20 random placements
    Builds on

    Search efficiency

    Best score vs. robot evaluations

      Across all 7 recorded treesmean evaluations to the best candidate

        0:00 / 0:00

        Two loops. One robot that keeps getting better.

        The inner loop solves today's task. The outer loop studies every past search and learns how to search faster next time.

        1. You set the goal and the limits

          A task in plain language, the workspace, safety bounds and what counts as success. You can step in at any time.

        2. Agents act and watch

          An executive composes skills, policies and planners. A monitor flags contact, stalls and drift as they happen.

        3. Agents research

          Failures get a diagnosis. New solutions get proposed, implemented and tested. Search picks the next experiment.

        4. The search itself improves

          Recorded discovery trees become a replay world. New search policies are tested there first, at zero robot cost.

        5. Evidence decides

          An evaluator the agents cannot edit verifies every candidate on unseen trials. Only then does a skill join the library.

        Hand it a paper. Get a skill back.

        Self-improvement is one way in. You can also give it knowledge directly: a paper, a repository or a research direction. It reads it, tests it on the robot and keeps it as a skill that later tasks reuse.

        1. 1 · You share

          • 2 · It extracts
            • 3 · It verifies
              • 4 · New skill, reused new Reused in
                • Any format.

                  Papers, code, lab notes or one sentence of direction from your team.

                • Tested, not trusted.

                  A method becomes a skill only after it works on the robot and passes the frozen evaluator. If it does not, you get the reason.

                • Reused everywhere.

                  Every later task can draw on it, and Dream learns when it pays off.

                Every attempt becomes data. And it can make data on purpose.

                Learning a task leaves a labeled record of what worked, what broke and why. Point the same system at collection, and it produces diverse, verified data at scale.

                A by-product of learning

                Each rollout keeps observations, actions, the decisions behind them, skill calls, events and an independent verdict.

                • Success
                • Recovery success
                • Near miss
                • Diagnosed failure

                Failures get a diagnosis

                Facts, hypotheses and confidence stay separate, so nothing unproven is treated as truth.

                FailureReport #rollout-0412
type        alignment_failure
observed    tip_offset_deg: 11.4
            ring_contact: true
hypotheses  grasp_transform_error  0.62
            pose_estimation_bias   0.21
            insertion_step_large   0.17
next        test 3 candidates

                Or point it at the data itself.

                Once a skill works, the same system can run it on purpose to produce data. It varies the conditions, aims every new episode at what the dataset is still missing, and keeps only what an independent evaluator has verified.

                • Coverage, not repetition. Each run goes where the data is thinnest.
                • Verified by default. Every episode carries a verdict; rejects keep their diagnosis.
                • Scales with robots. Many robots fill the same map in parallel.
                Data run skill insert v4 · 4 robots
                Verified episodes0
                Coverage0%
                Rejected, diagnosed0

                Next horizon

                From one robot to a whole lab.

                A lab's agent system grows the way a robot's does: one task at a time. Every finished task leaves something the next one builds on, until the lab's routine work runs under the scientists' command.

                1. 1
                  Instrument skills

                  Load the furnace, uncap a vial, place a sample under the probe. Learned like the demo above.

                  + skills
                2. 2
                  Protocols

                  Skills chained into a routine: prepare, anneal and measure a film batch. A scientist approves it once; every run is checked against it.

                  + protocols
                3. 3
                  Studies

                  A question with limits and a budget. The system designs each next experiment and gets better at choosing them.

                  + study strategiesexample: the study panel
                4. 4
                  The lab's own agent system

                  New questions start from the lab's skills, protocols and history. Scientists set goals and limits; the system plans, runs, reports and asks when it needs a decision.

                  + the lab's memory
                Scientist

                Find the anneal temperature that maximizes film conductivity. Stay below 450 °C. Budget: 24 runs.

                1. Arm
                2. Dispense
                3. Furnace
                4. Measure
                5. Update plan
                Run 0 / 24
                • Humans command. Goals, budgets and hard limits stay with the scientist.
                • Humans can step in. Approve, tighten a limit or stop at any time.
                Case in progress

                Transistor models that calibrate themselves.

                While building Hephorvis, we use semiconductor device modeling as a test task: fitting the EEHEMT compact model to GaN transistor measurements, work that is usually slow, manual tuning. The same loop applies.

                1. Check the data first. Units, bias, temperature and device sizes are verified; held-out devices are sealed before any fitting.
                2. Calibrate under a fixed judge. The agent chooses what to fit and how; a frozen evaluator scores every attempt.
                3. Report what is known. Fit quality, held-out accuracy and what the data cannot pin down are reported separately.
                4. Ask for the right measurement. It picks the one curve that resolves an ambiguity. In our synthetic tests it needed 1 extra curve where random picks needed 4.
                5. Grow its own tools. New model capabilities are tested on fresh data before use, and Dream replays past calibrations to improve the strategy.

                Ideally it is connected to the probe station and parameter analyzer: it measures, fits, validates and hands over a verified model card with all its evidence.

                Today: verified on synthetic devices and public ASM-HEMT benchmarks. Validation on real devices is next.

                Starting calibration

                Every task makes the system stronger.

                Skills accumulate. Search gets faster. What starts as one task becomes an agent system that knows its robot, then its lab.

                1. Today

                  One task

                  A goal and its limits become a verified skill.

                2. With every task

                  A robot's own agent system

                  Skills and recoveries pile up until new tasks start from strength.

                3. With partners

                  A lab's own agent system

                  Instruments, protocols and results learned around one lab's work.

                4. At scale

                  A fleet that learns together

                  Many robots, many experiments, shared verified discoveries.

                Intelligence in motion.

                We are building the system that lets any robot, and any lab, learn the work you give it.

                Watch the demo