Agentic AI. Advanced reasoning. A curriculum analyst, not a content generator.

Most tools turn a prompt into text. ArthurAI™ Studio is agentic AI with advanced reasoning: it researches the institution it is building for, searches everything you have already made, infers what you did not spell out, reasons in the open — you watch it think — and proves its work. Here is what is actually happening beneath the authoring surface, powered by Eve-Education™ F5/reasoner — and why a program it produces is grounded, aligned, and defensible rather than merely written.

A team of Arthurs, reasoning in the open.

• Agentic

  You watch it being built

  Studio does not hand back a finished course and ask you to trust it. Every stage is announced as it runs — grounding your sources, researching if you asked, designing the structure, authoring the lessons, building assessments, then convening the reviewer panel — with Arthur’s own reasoning streaming underneath. Course creation reads as work being done, not a progress bar.

• Advanced reasoning

  Watch it think

  Arthur runs on Eve-Education™ F5/reasoner — the Eve-Fusion™ compound reasoning architecture. Its reasoning streams live as it designs, so you see how a decision was reached rather than staring at a black box. Reasoning effort is calibrated per step — highest where a mistake would cascade through every lesson below it.

• Pipeline

  A real curriculum-design pass, end to end

  Not a single prompt: Studio works in deliberate stages — outline, courses, cross-cutting assessment, compliance mapping, provenance — each one a place a person can intervene, and each one visible as it runs. The stages are set out in full below.

• Resilient

  Self-healing generation

  A stalled run retries automatically at lower effort rather than failing, and bounded watchdogs mean a run never hangs — a stuck generation ends with an honest message instead of a spinner that never resolves.

It starts from your institution, not a blank prompt.

• Your material

  It teaches from what you give it

  Add a link, paste text, or upload a PDF. Studio splits it, embeds it, and retrieves the passages that matter while Arthur writes — so the course teaches from your material rather than from whatever the model happened to absorb. Or let Arthur interview your subject-matter expert and author from the transcript.

• The live web

  It checks what has changed

  Tick one box and Arthur researches the topic before writing — current standards, real figures, recent changes — and cites the sources the search actually returned. Off by default: a course silently grounded in whatever a search turned up is a course whose author cannot say where its facts came from. Opt-in per course, from Creator up.

• Your catalogue

  It sees what your courses teach between them

  Studio reads your published courses together and builds a skills graph of what they actually cover — and where the gaps are. It is how Arthur proposes the next course worth building rather than guessing.

Not a prompt box — a strategist you direct.

• Ask Arthur

  A strategist that works the problem

  Arthur Chat is agentic, not a Q&A box: given a question it plans, then searches the live web, reads your course library, opens any outline, and searches your own history before it answers — a full tool-using loop, with every call shown as it happens.

• Transparent

  Every step on a live timeline

  As Arthur works, a structured activity timeline shows the plan, each retrieval pass, and every tool call moving from running to done with what it returned. You always see what it consulted and why.

• Co-author

  Steer any lesson in plain English

  Point at a lesson and tell Arthur what to change — "make this more advanced," "add a real-world scenario," "simplify the language" — and he re-authors just that lesson in place, leaving the rest of the course alone. Or edit any word inline and drop in your own media.

• Proactive

  It suggests your next course

  Ask Arthur what to build next and he reads your catalogue as a whole — the skills your courses cover between them, and the gaps — and proposes the course that fills one, so catalogue strategy is a conversation rather than a guess.

You can see the work, and it is still there tomorrow.

• Reasoning you can read

  Watch Arthur think, then read it back later

  Arthur streams his actual reasoning while he authors, revises and answers — not a progress bar, the working. It is kept with the result too: every generated course carries Arthur’s own account of why it is sequenced the way it is, and every finished answer keeps the thinking behind it. The record is there long after the stream has gone.

• Live research

  Current facts, cited to what he actually found

  Ask Arthur about rates, regulations or anything recent and he searches the live web, then cites the sources the search returned — not URLs recalled from memory, which is how a confident fake citation happens. Authoring can be grounded the same way: tick one box and he researches the topic before writing, and what he found is saved with the course. Web search in chat is on paid plans; research while authoring is opt-in, per course, from Creator up.

• Every call, as it happens

  Nothing happens off-screen

  Each tool call appears the moment Arthur makes it — the search query assembling character by character, the course being opened, the history being read — each moving from running to done with what it returned. When the answer arrives, the whole sequence folds into a recap you can reopen on any past turn.

• It survives the interruption

  Close the tab. The answer keeps coming.

  A turn runs as a job on the server, not on your connection. Switch apps on a phone, lose signal in a lift, or close the tab entirely and the work carries on — the answer is waiting when you come back, with its reasoning and its tool calls intact. And when you do want it to stop, Stop actually stops it, keeping whatever was already written.

A multi-step design pass — and you can watch it think.

1. Outline

   It designs the whole course first

   Studio designs the course structure first — modules, lessons, objectives and how the hours divide — and streams that reasoning as it goes, so you see the shape the course is taking before any of it is written.

2. Courses

   It writes each course in full

   Course by course, Studio generates modules, subtopics, learning activities, key terms, assessments, and measurable outcomes — written in spoken-rhythm prose for narration, with hours that sum correctly and assessments that are specific ("a five-question scenario-based quiz"), not generic.

3. Cross-cutting

   It ties the program together

   It builds the competency-badge framework (foundation → practitioner → builder), the capstone project, and a program-level certification — each attestation written for the target audience and economy rather than boilerplate.

4. Compliance

   It maps every module to a requirement

   For each framework in play, Studio generates a compliance matrix: every requirement marked covered, partial, or not-covered, the specific modules that address it, and an overall coverage score. The artifact a funder or accreditor asks for is produced alongside the content.

5. Provenance

   It records how it got there

   Every artifact is stored with a full provenance trail — what Arthur proposed versus what you chose, the frameworks it considered (with confidence and source URLs), and a transcript of his reasoning. It is on the course itself, under “How Arthur authored this”, so months later you can open it and answer “why is this course built this way.”

Taught from your sources — and able to prove it.

• Ingest anything

  Your sources become teaching knowledge

  Add a document, a web page, pasted text, or let Arthur search the live web. Studio chunks it, summarizes it, embeds it, and indexes it — so the exact passage can be retrieved and taught from the moment it is relevant.

• Cited & checksummed

  Grounded, and provable

  Content drawn from a source carries a citation back to it, assembled into a grounding manifest with honest coverage counts, and the whole course is fingerprinted with a SHA-256 content hash. A reader can see what a claim rests on; a receiver can confirm the content arrived intact.

Capabilities the prompt-box tools don't have.

• From an interview

  Turn an expert into a course

  Interview a subject-matter expert in a guided conversation; Arthur captures the transcript as a grounding source and authors a complete, cited course in the expert’s own substance. Institutional knowledge that lived in one person’s head becomes teachable courseware.

• Self-improving

  Improve a course from what learners did

  Publish to an ArthurAI™ edition, then bring its aggregate, PII-free learner signal back into Studio. Arthur ranks the weakest lessons — where learners drop off, which checkpoints are hardest — explains why, and re-authors any one of them on a single click.

Courseware you can test, like software.

• Simulated learners

  Four learners take the course before anyone pays for it

  A complete beginner, an experienced practitioner, a time-pressed skimmer and a non-native English speaker each read the course as that person and file what tripped them — where they got lost, what it assumed and never taught, which assessment asks about something the content never covered. Every finding arrives with a ready-to-run instruction, so the fix is one tap rather than a note to yourself.

• Course health

  A pedagogical lint, and a panel that argues about the result

  Structural checks run instantly and at no model cost — modules with no assessment, lessons with no objectives, content too thin to teach from, an unbalanced outline. Then a panel of specialist reviewers audits alignment, readability and structure, disputes each other’s findings, and a lead reviewer rules on what they cannot settle. You get a score, the outstanding list, and the deliberation that produced both.

• Living courses

  It tells you when the world moved under a course

  Two concurrent passes look for claims that have aged — a figure with a year on it, a rule that has since changed, a tool that has been renamed — and for statements that drift from current practice. Each finding says what to verify and carries the revision instruction to fix it. A course written eighteen months ago is not silently the same course.

• Arthur noticed

  It reviews the workspace without being asked

  A sweep runs on a schedule across every course you own and raises what needs attention: a course whose health has slipped, a draft that has gone quiet, one that is structurally ready to publish. Deliberately deterministic — these are rules, not a model guessing — so the same course produces the same notice every time.

Eight languages, and a link that needs no LMS.

• Eight languages, one tap

  Translate a finished course without re-authoring it

  Spanish, French, German, Portuguese, Arabic, Hindi, Simplified Chinese and Japanese. Studio produces a new draft course and leaves the original untouched, verifies the structure survived, and where a lesson fails that check it keeps the original text and tells you which one — a translation that quietly dropped a module would be worse than none. Right-to-left languages are laid out as such, through the player and into the export.

• No LMS required

  A hosted course, a link, and an embed

  Publish to a hosted player and share a link — on every plan, including free. Progress and checkpoint results persist for the learner, the quiz is graded on the server rather than in the browser, and an embed mode drops the course into a page you already run. Each course gets a share card generated for it, so the link looks like something when it is pasted.

The people who have to approve it don't need a licence.

• Reviewers without seats

  Send the course to someone who does not have an account

  Mint a link scoped to one course. Your reviewer reads it lesson by lesson and leaves comments tagged to the lesson they are about, with no account, no seat and no licence. Links expire, can be revoked the moment you want them closed, and comments come back into the workspace where you resolve them — or hand the whole set to Arthur to address at once.

• Approval, enforced

  Nothing reaches a learner until a named owner signs off

  Submit for review, approve, or send back with changes — on every plan. Publishing refuses a course that has not been approved; it is a rule in the software, not a step in a process document. And editing an approved course drops it back to draft, so an approval always attests to the exact content that shipped rather than to something it used to be.

• Versions

  Save a version, restore a version

  Name a version before a big revision and roll back to it if the revision went somewhere you did not want. Every course also carries its own authoring history — who generated it, who revised it, who approved it, with actor and timestamp.

The procurement answers, available on every plan.

• Your account

  Two-factor authentication, on any plan

  Time-based one-time codes from the authenticator app you already use, with recovery codes issued once and shown once. Available on every plan, because an account that can author your institution’s training is worth protecting whatever you pay for it.

• Your data

  Export it, or delete it, without asking anyone

  Download a structured export of everything held about you. Or see exactly what a deletion would remove before you confirm it, then delete — immediately and irreversibly, with no grace period to explain away. Data-subject rights that need a support ticket are rights on paper.

• What it cost

  Usage you can see, per workspace

  Authoring is metered and the meter is visible: what this workspace has spent, how it sits against the plan’s monthly budget, and which courses accounted for it. The budget is the real governor of a plan — courses are uncapped — so it is shown rather than discovered at the limit.

Outcomes that count — measured, graded, credentialed.

• Skills graph

  What your catalogue teaches, between courses

  Studio reads your published courses together and builds a skills graph of what they cover between them — and where the gaps are — so your catalogue can be reasoned about as a portfolio rather than a list, and Arthur can propose the next course worth building.

• Credentials

  Verifiable, standards-based badges

  A passed compliance attestation issues a credential carrying the training, the issuer, the score and an expiry — with a public link an auditor can check without an account. Not a certificate image; a record confirmed at source.

• Paths

  Courses that assume what came before

  Declare assumed prior knowledge and prior courses on the brief, and Arthur writes to them — building on what learners already have instead of restating it, so a second course does not re-teach the first.

• Assessment

  Real, gradable checkpoints

  Compliance trainings ship real checkpoints — multiple-choice items with a stored answer key, a pass threshold you set, and grading that happens on the server, never in the learner’s browser. An attempt cap is enforced in the database, so a retry cannot be bought with a page refresh.

Author once. Ship it to any platform you run.

• Your LMS

  SCORM 1.2 and xAPI, out of the box

  Export a course as a standard SCORM 1.2 or xAPI (Tin Can) package that imports into Moodle, Canvas, Blackboard, or whatever you already run — and reports completion and scores back to it. A SCORM 2004 (4th Edition) package is available on Team and up; its run-time reporting is carried over SCORM 1.2.

• For people

  A printable course, and a facilitator’s kit

  Export a clean, printable course PDF for stakeholders and procurement, carrying your copyright line and the Eve-Education™ F5/reasoner authoring attribution — and, on Team and up, a facilitator’s instructor kit in Markdown with each lesson’s objectives.

• To an edition

  Straight into an ArthurAI™ edition

  Publish a course directly into the matching ArthurAI™ edition, wrapped in a provenance envelope with a content hash the receiving system re-verifies byte-for-byte on import — and rejects on mismatch. Corruption in transit cannot land silently.

• Fidelity

  Your exact words, or adapted per edition

  Choose per course how it is taught: rendered verbatim as you authored it, or re-expressed by each edition in its own voice for its learners. And author in the language your learners speak — language carries through every export.

Built for procurement, not just for authors.

• Governance

  Nothing ships without sign-off

  A course is a draft until a named org owner approves it, and approval is physically load-bearing — unapproved content is blocked from delivery and publication. Edit an approved course and it drops back to draft, so an approval always attests to the exact content that shipped.

• Accountability

  An immutable audit trail

  Every action — create, edit, approve, publish, push, export — is written to an append-only, per-tenant audit log with actor, resource, and timestamp, and can be exported to CSV for auditors. Paired with each course’s full generation provenance, you can always answer who did what, and why the course is built the way it is.

• Isolation

  Hard tenant boundaries, least-privilege roles

  Every institution is an isolated tenant; one can never see or address another’s data. Access is scoped by role — owners approve, contributors create, readers observe — and enforced at the API gate, not just hidden in the UI.

• Private AI

  Keyless, private, and unbranded

  All reasoning runs on a private Azure AI Foundry endpoint authenticated by managed identity — no API keys to leak, no public model endpoint in the path. And your learners only ever see Arthur and Eve-Education™: a third-party model name never appears on any surface.

• Your data

  Not the training data

  Arthur’s reasoning is built on MindHYVE.ai’s proprietary Eve-Genesis™ synthetic dataset — your organization’s profiles, frameworks, and authored courseware are never used to train the underlying models. They stay in your tenant.

• Data rights

  Export, erase, retain — on your terms

  A complete, structured export of everything your org owns; a guarded, server-confirmed right-to-erasure; configurable retention windows with automated purge; and token-level cost metering broken down by organization and user. Governance you can hand to compliance.