The Autonomous Intern 2 Developer Edition can run small AI models locally, but turning that into a useful voice assistant proved much harder. Cloud-backed briefings and scheduled tasks gave this little pyramid a more convincing job.

Estimated reading time: 15–17 minutes

2026 has been a case of Kevin biting off far more than he can chew. When I agreed to review the Autonomous Intern 2, I wasn’t thinking ahead to the rabbit hole I would end up in. Of course, instead of taking the potentially simpler route with the OpenClaw or Hermes edition, I chose the Developer Edition for the full rabbit burrow experience.

The Intern 2 is a plug-and-play agent server housed in a little pyramid, complete with an LED capstone that immediately brings to mind a Matthew Reilly adventure featuring Jack West Junior.

My particular unit came personalised with the DRN logo, a service Autonomous offers free of charge with a purchase.

Diving in Head First

I asked the Autonomous Intern 2 a fairly mundane question: what does a lamp do?

By that stage, I had compiled a local AI engine, downloaded a small language model, configured a background service, changed the assistant’s model endpoint, expanded its context window and reduced its available tools.

Eight minutes into processing the request, it had read less than half the prompt. It had not yet started delivering the answer.

That sounds like a damning result for an AI device review, but the story needs some context. This was my attempt to make the Developer Edition’s built-in voice interface use a language model running on the device itself. It was a custom experiment, and it behaved very differently from the cloud assistant already available on the Intern.

The Intern proved it could run small AI models locally. Getting that ability to produce a practical voice assistant was where my evening became considerably longer than planned.

Autonomous Intern 2 WebUI System Overview

What Is the Autonomous Intern 2 For?

Autonomous positions the Intern 2 as a dedicated computer for AI agents: a device that can stay on your desk, receive requests and run tasks while your main computer is occupied or switched off.

The Developer Edition opens up the underlying system so you can install software and change the agent framework. Autonomous’s product page outlines that approach.

I went into this review as the underdog. Joanna is my AI guru on the team, but I wasn’t about to back down from a learning opportunity.

I wanted to explore what this little pyramid could do with its own hardware. It can connect to a cloud model, but I wanted to see how much useful AI work it could perform locally.

How much AI did the Intern actually need to be useful? Could it extract details from an announcement, summarise a short passage, fetch information using a tool, or answer a simple spoken question?

That gave me concrete tasks to test, rather than simply checking whether an AI assistant could sound enthusiastic about helping.

Intern 2 Hardware and Everyday Use

The Intern 2 sports an Orange Pi 4 Pro board. Autonomous lists an eight-core Arm processor with two Cortex-A76 cores and six Cortex-A55 cores, 6 GB of RAM and 64 GB of storage. It also lists dual microphones and a 5 W speaker.

Initial setup is through the Autonomous app, which I already had installed from my earlier Autonomous Key review.

The basic setup was pretty painless, although getting things working needed some understanding of what the Intern 2 is for. Microphone pickup is decent, but there were times it seemed to miss me. I couldn’t tell whether I had said the trigger incorrectly or it was still busy.

Fan noise is low, but you can hear it in a quiet room when it spins up. The LED capstone can be bright, especially in a dark room. Asking the Intern to play relaxing music also triggers a very Close Encounters of the Third Kind light show. The speaker is fine for conversational tasks, but it won’t trouble an audiophile’s wish list.

On my unit, the command line identified the operating system as Debian 12 Bookworm with an Orange Pi image. Linux reported approximately 5.7 GiB of usable memory and an eight-core processor with both Cortex-A55 and Cortex-A76 cores.

That is enough hardware for an interesting experiment. It is also a good reason to keep expectations sensible. Local AI can consume RAM quickly, with both the model and the amount of text it processes affecting how much memory it needs.

The board includes an integrated GPU, but my local model tests ran on the CPU. The supplied software image did not expose a working Vulkan driver in my checks, so I could not test GPU acceleration.

Once the Intern 2 is onboarded, you can configure it through the app, although I found that interface a little limiting. Alternatively, you can grab its IP address and open the web interface in your favourite browser.

Having full access to the CLI (command-line interface) makes life easier for a geek like me.

Once something went wrong, I could inspect services, configuration and logs rather than relying entirely on a spoken error message.

On one hand, this meant I quickly moved beyond the sort of setup I would expect an ordinary buyer to tackle. On the other, I did choose the Developer Edition, which is designed for tinkering.

Beyond the browser-based command line, you can also establish SSH access for a more conventional connection. Root access worked through the web terminal, but direct root login over SSH was disabled. The regular account was orangepi.

The Intern 2 can listen for spoken requests, but my unit does not provide presence or motion detection. Its device configuration explicitly excludes those capabilities.

Running Qwen Locally on the Intern 2

I built llama.cpp directly on the Intern. In plain language, this software loads a language model and runs it on the machine.

I started with Qwen3 0.6B, then moved to Qwen3 1.7B. The numbers refer to their approximate parameter counts; both are small models compared with the systems behind the major cloud chatbots.

Both models used Q8_0 quantisation, which reduces the precision of the model weights to lower model size and memory requirements. The initial short tests used two CPU threads, so these figures describe that configuration rather than the device’s maximum performance.

Local model Observed text generation
Qwen3 0.6B Q8_0 Around 12–13 tokens per second on the initial short tests
Qwen3 1.7B Q8_0 Around 4.5–4.8 tokens per second on the short tests

A token is a piece of text, often part of a word. These figures came from individual test runs, rather than a formal benchmark suite, and varied with the prompt and conversation.

The smaller model was quick enough to make short text tasks worth exploring. The 1.7B model was noticeably slower, but it still produced responses locally.

That was a useful result in its own right. The Intern was doing the language-model computation, rather than simply displaying an answer generated by a remote service.

Autonomous Intern 2 WebUI Robot Overview

Local AI Tests: Extraction and Summarisation

For a simple extraction test, I supplied a sentence about a desk lamp costing $89 and launching on 13 October.

The smaller Qwen model returned the product, price and date in a JSON object. JSON is a structured text format that software can read, so this is the sort of task that could feed information into another application.

I also asked it to summarise a fictional announcement for the DeskLight Mini in one factual sentence, preserving its A$89 price and Australian availability date.

Both examples showed that a small local model could handle narrowly defined text work.

For my purposes at Digital Reviews Network, extracting details from announcements is a more relevant experiment than asking a tiny model to write an elaborate haiku.

Where Structured Extraction Fell Short

The next announcement deliberately omitted Australian pricing, a confirmed Australian release date and warranty information. It said Australian pricing and launch timing would be announced later; warranty information was not stated.

I asked the model to extract the product and use null for anything not explicitly stated. That value means there is no confirmed information to put in the field.

The product name was present. The other requested details were not.

This was where reliability became a problem. In different attempts, the smaller model treated a mention of Australia as availability, added unwanted fields, wrapped its output in Markdown or left the explicitly named product blank. Clearing the chat and tightening the instructions did not make every response correct.

The 1.7B model extracted the product in a later attempt and returned null for the unknown values, but misspelled the required australian_availability key.

That typo might look trivial on screen. To software expecting an exact field name, it can mean the result is unusable.

A model can produce tidy-looking text and still fail the job. For a workflow processing product announcements, I need it to preserve confirmed facts, leave gaps honestly and follow the structure every time. These limited tests did not establish that level of reliability.

Joanna reached a similar conclusion in her HP ZBook Ultra G1a 14 review: running a model is only the beginning of building a useful, trustworthy workflow.

There may be ways to improve the result with constrained output and validation, but those were not implemented in this test.

Checking How the Voice Assistant Fetches Weather

I then tried something familiar: asking Otto, my voice assistant, for Melbourne’s weather.

A language model does not know the current weather simply because it can describe weather convincingly. It needs access to a live source.

Fetching a short weather report from wttr.in with a terminal command worked. Hermes, the agent framework running on my unit, could also execute that command and report the result through its text interface.

The built-in voice experience initially followed a different route.

The logs showed that the realtime voice assistant was using Gemini Live, with Google Search grounding, and answered without handing the request to Hermes. It gave a temperature and suggested taking a jacket.

When asked about the source, it said it had just used wttr.in. The logs I inspected showed the search query and no Hermes handoff; they did not demonstrate the terminal fetch I had requested.

A plausible weather report did not prove it had followed my instructions.

After disabling the realtime path, a spoken request went through the operating-system service to Hermes. The logs showed terminal execution, and the voice interface read out a weather response.

That proved the voice assistant could hand the job to Hermes and have Hermes use a live tool.

Autonomous Intern 2 - App General Screen

Connecting the Voice Assistant to Local Qwen

The next step was to point the assistant’s language-model settings at the Qwen server running on the Intern.

Autonomous documents separate settings for the language model, speech recognition and speech output. Its custom-model guide also explains that speech services need their own settings preserved when the model endpoint changes.

Autonomous labels custom model endpoints as experimental. Its documentation also explains that changing the model URL affects other services, including speaker recognition, which has no separate endpoint override.

I kept recognition and spoken output on their existing cloud services. This was therefore an experiment in local text generation behind the built-in voice interface, rather than a fully offline voice assistant.

A direct request to the local model server succeeded. It replied, “Local Qwen is ready.”

The device configuration then showed the local server URL and the Qwen3 1.7B model. A subsequent voice-turn log confirmed Hermes was using that model.

At that point, the pieces were connected. The remaining question was whether they could deliver a useful response.

Why a Simple Voice Question Became a Large AI Workload

The installed Hermes version required a context window of at least 64,000 tokens. That is the amount of text a model can work with in a request, including instructions, conversation and the answer — not simply the length of my spoken question.

The local model server fell short of Hermes’s requirement. I extended its context window to 65,536 tokens and compressed its context cache to reduce memory use, which got the request past the compatibility check. This was a workaround to satisfy Hermes, rather than evidence that the small model could handle a 64K context effectively.

The larger configuration left around 1.1–1.2 GiB of available memory. Some swap was in use, but the samples I checked did not show ongoing swapping explaining the delay.

The bigger problem was how much text Hermes supplied alongside the question: instructions, context and tool information. The first run’s progress suggested roughly 17,000 input tokens. Reducing the toolset to terminal access and increasing prompt-processing threads from two to four brought the next run to approximately 9,000.

Even after that reduction, asking what a lamp does gave this small model a substantial reading job before it could answer.

Autonomous Intern 2 - App Agents Screen

The waiting became the result

The trimmed request started processing at 22:18.

After about two and a half minutes, Qwen had processed 2,048 tokens, or 23% of the prompt. Its average rate at that point was 13.43 tokens per second.

At approximately eight minutes, it had reached 4,096 tokens, or 45%. The average had fallen to 8.48 tokens per second.

At 22:33:01, approximately 15 minutes after processing began, the server logged a cancellation of the task. The supplied log showed no completed response before that cancellation. It did not identify what triggered the cancellation, so I cannot say whether it was a timeout, a user action or another component ending the request.

The rate slowed as the model worked further through the prompt, so this was not a simple countdown to a reply. This Intern was struggling.

For a background experiment, that might be tolerable. For a person asking what a lamp does, it is plainly impractical.

Those short command-line demonstrations and this voice test were running very different workloads. A model that can generate text at several tokens per second can still take minutes to work through the assistant framework’s instructions before it begins answering.

I could not measure whether later turns would benefit enough from cached instructions to change that experience. I had no completed baseline query.

Voice Recognition Added Its Own Friction

One attempt was also transcribed as “Okay. All closed.” The listening system marked it as not addressed to the assistant, so it never reached Hermes or Qwen.

A later attempt was accepted and did reach the local model. That let me distinguish a recognition failure from an inference delay.

The logs also showed speaker identification calling an endpoint the local language-model server did not provide. It returned a 404, identification was skipped and the request continued.

The logs were valuable because they made those differences visible. Without them, I would have been left trying to interpret acknowledgements, waiting sounds and silence.

Autonomous Intern 2 - WebUI Trigger Words

What I could and could not establish

I successfully compiled and ran llama.cpp on the Intern, used two small Qwen models locally, completed simple text tasks, exposed a local model endpoint and routed a spoken request to it through Hermes.

I also demonstrated live weather retrieval through the terminal and through the cloud-backed Hermes route.

I did not establish dependable structured extraction, a practical local-Qwen voice response time, local-Qwen weather tool use or a fully offline speech pipeline.

I did not test NPU acceleration; my llama.cpp setup used the CPU. I also did not test alternative local models, constrained JSON generation, long-term unattended operation or the wider range of advertised integrations. These tests exposed limits in the small models and in my custom voice configuration.

The most severe waiting occurred in the custom local configuration I assembled. After restoring the cloud-backed setup, I completed the short voice test and a current-news briefing, as described below.

Cloud AI and Scheduled Tasks: What Worked

After the local experiment, I restored the Autonomous Auto-AI model with Hermes, removed the context and toolset overrides, and stopped the local Qwen server. Available memory recovered to approximately 4.9 GiB, and the short spoken lamp question worked again.

I also connected the Intern to Telegram, which required creating a Telegram bot and entering its token and my user ID in the Autonomous app. That gave me a text interface I could use away from home, as long as both the Intern and my phone had an internet connection, without relying on voice recognition.

A weather request through Telegram triggered terminal tools, confirmed in the Hermes logs. A follow-up cross-check returned in about 16 seconds, although I still had to prompt it to question an ambiguous weather timestamp.

Autonomous Intern 2 - Scheduled (WebUI view)

Scheduled Tasks- WebUI view

I then ran the morning-news-brief task with a specific instruction:

Give me the three biggest news stories since last night — world first, then my country — one short line each, under 350 characters in total. It’s spoken aloud, so no links, lists or source names. Never make up a story; if you can’t get live news, say you couldn’t check.

The briefing took a few minutes to complete. It covered a bridge strike in Kyiv, the rugby league grand final result (Knights lost by 1 point) and a tornado in New South Wales. I checked the stories, including the match result, and found them accurate.

That was a useful success. A few minutes is a very different proposition for a briefing prepared ahead of time than for a simple question asked in conversation.

The instruction gave the assistant a clear job: prioritise world and Australian news, keep the result short enough to hear comfortably, and admit when live information cannot be checked. For this run, the factual content held up when I checked it.

This cloud-backed run showed where the Intern’s dedicated agent-computer approach could be useful.

The scheduled morning briefing and other reminders also ran successfully the following morning without me manually starting them. That confirmed unattended execution in the restored cloud-backed configuration.

I have noticed some inconsistency in the schedule trigger, so if you need it to run at a precise time, there may still be some tuning required.

Hermes initially missed the tasks shown in the app because it checked its own scheduler. After finding the separate device scheduler, it saved a reusable skill. In a fresh conversation, it found the tasks without further guidance, although it miscounted the entries and still offered an unverified explanation for their timing.

Autonomous Intern 2 - Telegram Bot

A More Useful Assignment: Watch the Grocery Specials

After all that testing, a more practical assignment came from my kitchen.

My store-bought butter was running low, and I have a Thermomix. Rather than repeatedly checking supermarket prices myself, I asked Padawan, my Telegram-connected Intern, to watch for discounted 600 mL cream so I could make my own butter.

It asked which supermarkets to monitor. I chose Coles and Woolworths, then added ALDI. The agent searched for the products, reported baseline prices and created a recurring price-watch job in Hermes’s scheduler.

Unlike the app’s existing reminders, this watch went into Hermes cron. When I asked it not to check overnight, it updated the schedule to 8 am, 2 pm and 8 pm Melbourne time.

This felt much closer to a useful assignment for an Intern: keep checking something mundane, then tell me when there is a reason to act. Whether discounted cream makes economical butter is a separate calculation, but remembering to look for the discount is a chore I could hand over.

Encouraged, I asked for a daily midday check of fruit and vegetable specials, with discounted vegetables potentially destined for Thermomix stock.

The agent reported creating that watch too, although retailer access proved troublesome. Its repeated setup checks reportedly triggered Coles’s rate limit, so it configured the job to continue with the other stores when one was inaccessible.

Then I checked one of its recommendations.

Padawan had reported whole fresh beetroot at $2.70, reduced from $3.20. The Woolworths website I was looking at showed beetroot at $1.95 each, without a special.

When challenged, it fetched the information again and explained that its result referred to a 250 g punnet, while mine was loose beetroot sold individually. It had omitted the pack size—the detail needed to understand the price.

That led to a more useful instruction: before telling me something is a deal, establish that it is good value, rather than simply a price drop.

The agent reported updating both watches with a minimum 20% discount, unit-price comparisons and clearer product descriptions. It also added price history and changed the produce digest to stay silent when nothing qualified.

That was encouraging, but its explanation of the revised checks contained another problem. A mushroom comparison mixed a 200 g quantity with a price calculation that did not follow from it. It also had not established that the cheaper alternative was a comparable fresh product.

This was a learning curve for me too. “Find specials” sounded straightforward, but it left plenty of room for results that were technically discounted without being useful purchases. I needed to explain what mattered: comparable products, meaningful savings, correct quantities and alerts at sensible times.

Clearer instructions made the proposed workflow more useful. They did not remove the need to check its work.

Both watches were reported as configured, but I had not yet watched them deliver a verified bargain through a scheduled run. I could delegate the repeated searching; trust in the recommendations still had to be earned.

By the time we finished setting up and refining these watches, I had exhausted my daily cloud allowance. That was before either watch had delivered a verified bargain on a scheduled run. The setup involved repeated searches, troubleshooting retailer access and correcting the agent’s comparisons. Whether the ongoing checks consume far fewer tokens is something I still need to establish.

Intern 2 Cloud Plans and Subscription Costs

The working configuration depends on an internet connection and cloud services. Autonomous’s free plan includes 10 million tokens per day. Pro increases that to 50 million tokens per day for US$20 a month, while Max provides 100 million tokens per day for US$100 a month.

Cloud plan Daily token allowance Monthly price
Free 10 million Free
Pro 50 million US$20
Max 100 million US$100

That is a sizeable jump from Pro to Max: five times the monthly price for twice the daily token allowance. Whether either paid plan is worthwhile will depend on how much work you give the agent and how many tokens those jobs consume.

A short request does not necessarily mean a small token workload: the agent processes instructions, conversation history and tool results alongside your question. By the end of the grocery-watch setup and troubleshooting, I had exhausted my daily cloud allowance. I cannot attribute all that usage to the watches, and I have not yet measured their routine consumption, but the free allowance proved possible to exhaust while building a useful workflow.

Autonomous Intern 2 Bottom view

Autonomous Intern 2 Review: My Verdict

I went looking for how much AI this little pyramid could run by itself, and found the limits fairly quickly. Small local models worked on short text tasks, but my attempt to put Qwen behind the built-in voice assistant became impractical.

The more practical role for the Intern became clearer through this testing: give it a defined job, let it work in the background, and check the result when it is ready. A briefing taking a few minutes is perfectly reasonable if it is prepared before breakfast. The same delay feels very different when I am standing beside it waiting for an answer.

The scheduled briefing worked, Telegram gave me another way to send requests, and the grocery experiment turned a household chore into two reported monitoring jobs. Those are more concrete reasons to keep the Intern working than its ability to hold an enthusiastic conversation.

The grocery watch also helped me understand what I needed to bring to the arrangement. AI can be useful, but I have to give it good instructions. “Find me a deal” leaves room for an expensive product with a discount sticker. Explaining the products, quantities, savings and notification rules gave it a much clearer assignment.

Even then, it made mistakes. Better instructions improved the proposed workflow, but they did not guarantee accurate comparisons or dependable execution. The watches still need to prove themselves through scheduled runs and checked alerts.

The appeal is having a separate, always-on computer hosting the agent, its tools and its working environment while my main machine gets on with other things. In the configuration that worked best for me, the heavier language-model processing happened in the cloud.

That also means the purchase needs a purpose. If all I want is an occasional chatbot conversation, I already have devices that can do that. The Intern earns its place on my desk if it can repeatedly take a chore off my plate with less effort than doing it myself.

The Developer Edition gave me plenty of room to tinker, and I certainly exercised that privilege. Its more convincing role is hosting an agent that checks, gathers and prepares things on a schedule. Whether it saves me time will depend on how consistently it finishes those jobs, how much supervision it needs and how many cloud tokens it consumes.

Getting more from it may mean granting access to accounts, files or services. The level of trust required depends on what you let it read and change. Keeping the agent on a separate computer does not remove that responsibility.

The Autonomous Intern 2 has an RRP of US$299 for the OpenClaw and Hermes editions. The Developer Edition is a little more at US$349.

DRN would like to thank Autonomous for providing the review unit. This one is a full rabbit colony to explore.

And if you want to remove the Intern from your account, the big red button says “Fire this Intern”. Well played Autonomous. Well played.

Autonomous Intern 2: Fire this intern