In testing — early access open

Generate the assignment.Grade the submissions.Show the work.

Agoge Development builds assessment tooling for analytics courses — SQL, Excel, Power BI, Tableau, Python, R and statistics. One specification produces the assignment students receive, the rubric that scores it, the full answer key and a private TA guide. The graders score real submissions against that same rubric. The tutorial engine records the walkthrough, running every query against a live database as it goes.

excel-01-northwind-sales one spec
  • assignment.pdf7 KB
  • rubric.pdf7 KB
  • solutions.pdf13 KB
  • instructor-guide.pdf30 KB
  • starter.xlsx11 KB
  • solution.xlsx13 KB
  • student-submission.xlsx13 KB
  • graded-report.pdf59 / 100
Everything above came out of one specification, then the grader scored a synthetic submission against it — the score is what the grader returned. Download the package →

9 graders 6 assignment generators 438 REST endpoints 1,274 automated tests D2L import and gradebook export 2 ways to run it — local or hosted self-hosted

Proof, not screenshots

Look at the output before you talk to us

Two public showcases, both generated by the running system rather than assembled for a pitch. Nothing on either page was touched by hand after it came out.

How it fits together

The grader already knows the answer, because the generator wrote it

Most tools do one of these three things. The value is in the seam between them: an assignment whose rubric is machine-checkable, graded by something that has the key, and explained back to the student by something that can replay the solution.

01 — Generate

One specification, four documents

Pick a schema — Sakila, Northwind, Chinook, or your own — set difficulty and skill coverage, and the generator emits everything at once. Multiple versions of the same assignment keep an exam honest.

Excel rubrics carry machine-checkable assertions. That is how the grader later tells a hard-coded number from a calculated one, and a correct formula in the wrong cell from a missing one.

assignment · rubric · answer key · TA guide · starter.xlsx · solution.xlsx

02 — Grade

D2L ZIP in, marked work out

Import the submission ZIP straight from Brightspace. Each question is scored against the rubric with partial credit — logic and approach, not string matching, so a student with the right idea and a typo does not get a zero.

Feedback PDFs come back named to match the file each student submitted, ready to re-upload, with a gradebook CSV alongside.

per-question scores · partial credit · feedback PDF per student · gradebook.csv

03 — Explain

Replay the solution, clause by clause

The tutorial engine takes a marked answer key apart in the order it was built — base table first, each join as the columns it brings arrive, then the filter, then the sort — and runs it after every stage.

Students see what each clause did to the data: which rows the WHERE removed, the moment a join multiplies 2,500 rows into 4,000, and why.

staged walkthrough · live row diff · two-voice narration · captions · MP4
AI proposes the grade. The instructor approves it. That line does not move.
A design constraint, not a slogan — every grading workflow in the platform requires instructor review before anything reaches a student. Calibration profiles let each instructor set target strictness so the proposals land where they expect.

New — Agoge CourseOps

Same engines. Two ways to reach them.

Everything in the module list below is one codebase, and both products run all of it — the same nine graders, the same generators. What differs is how you get at it and what you are buying. Agoge Platform is a hosted service licensed by module, for a department standardising on a set of capabilities. Agoge CourseOps is the same engines installed on your own machine, licensed once, for the instructor building and revising a course.

Schematic: one shared block of engine modules in the centre, connected on the
                  left to a single workstation and on the right to a stack of servers fanning out
                  to many users. The same engines, reached at two different scales.
The engines do not fork. A grader running on one instructor's laptop and the same grader running for a whole college are the same code with different packaging — not a cut-down edition and a real one.

Agoge Platform

Licensed by module, for a department standardising on a stack

The hosted service, bought as a vertical stack: license the modules your courses actually use. This is the path when the unit of the decision is a department rather than an instructor — shared organizations, co-instructors and graduate assistants on the same courses, institutional sign-on, and a bill that goes to the college.

  • ShapeMulti-tenant web application — organizations, departments, co-instructors
  • BuyingPer module, per vertical — SQL, Excel, Tableau, Power BI and the rest priced separately
  • EnginesNine graders and the generators — the same ones CourseOps runs
  • Runs onOur infrastructure, or inside your network
  • AIPer-function choice of provider, including fully local Ollama

Agoge CourseOps New

Installed on one machine, for the instructor building the course

A course development studio where a course is a folder of files, edited in conversation with an AI assistant, previewed as it will look in the LMS, and exported as a D2L import package — with the graders alongside it, so the assignment you just wrote and the marking of what comes back are the same workspace. It ships as a container you start yourself: no server, no IT ticket, no procurement cycle before you can try it.

  • ShapeLocal container on your machine — data in your Documents folder
  • BuyingOne licence for the studio — not a per-feature stack
  • EnginesThe same nine graders and generators, plus course authoring, review state and D2L export
  • Runs onYour laptop first, a department server later, same GUI
  • AIYour own subscription or API key — the spend is yours, and so is the account

Bring your own model

CourseOps has no AI account of its own to sell you. Every generator routes through a single bridge onto whichever assistant you signed in to — a ChatGPT EDU or Plus seat your institution already pays for, or an API key you hold. No generator reaches a provider on its own.

Two things follow from that. The per-token cost lands on an account you control rather than arriving as a line item from us. And because the assistant is yours, the question of which vendor holds your course material is one you answer, not one we answer for you.

Much of the work needs no model at all. Seven of the eight generators produce something real with no assistant configured — a full dataset, a rendered deck, a starter workbook, a complete Power BI project, a Tableau packaged workbook. The graders split the same way, and the interface tells you which is which: whether a cell holds a formula rather than a typed-in number is settled by inspection, while whether it is the right chart for the data is a judgement that needs a model. You can see that split per grader before you run anything.

Where the course material sits

At the local tier this stops being a policy promise and becomes a fact about the network. The container runs on your machine and writes to a folder in your Documents directory. Course content does not leave the laptop unless you point a generator at a cloud assistant, and that is a per-action choice.

On a managed university machine that folder is usually already synced by OneDrive, so backup is something you have rather than something you configure. Moving to a new machine is copying a folder. Replacing the container never touches it.

Courses move between installs as a zip — export from one, import to another — which is also how a course gets handed to a colleague or lifted onto a department server.

The CourseOps iteration loop, drawn inside one machine Four stages — draft, generate, review, publish — connected left to right, with a revise arrow running back from review to draft. All four sit inside a dashed boundary labelled "your machine". The only arrow that crosses the boundary is the D2L package leaving at the end, and a separate note marks the one optional call out to the AI assistant you signed in to. YOUR MACHINE The course is a folder of files here. Nothing in this box leaves it. 01 Draft Outline, syllabus, the week you are on 02 Generate Assignment, dataset, rubric, deck, key 03 Review Read it, grade a test submission, mark it done 04 Publish Hash-locked D2L import package revise — as many times as it takes, no one waiting on you the one optional step out: your own AI assistant, on your own account To the LMS
The loop CourseOps is built around. Everything but the last arrow happens on your machine — the course material only leaves when you publish it, and the one dashed line is the assistant you chose, billed to your own account.

The same GUI at three sizes

Tiers are packaging and configuration, not separate products. An instructor who starts on a laptop and a college that later runs it centrally are using the same application, and the courses built in the first are the courses served by the second.

  • Local app One instructor, own machine, own AI sign-in. Courses shared by zip export and import. no IT involvement
  • Department server A college or department. Adds memberships — co-instructors, graduate assistants, undergraduate learning assistants — against shared courses. a box and backups
  • Campus Planned Institution-wide. Adds single sign-on and direct publish into Brightspace rather than export-then-upload. a real deployment

What is built

The platform

Everything below is running today unless marked otherwise. It is one FastAPI application behind a React front end, self-hosted on our own hardware, with the whole surface exposed as a documented REST API. These are the engines both products run on — every grader and generator below is also what you get inside CourseOps on your own machine. The list is the capability; the two products are two ways to reach it.

Graders

9 All accept D2L submission ZIPs and export a gradebook CSV.

SQL

Rubric checks plus AI semantic analysis. Multi-form detection, schema validation, and enforcement of a house style if your course has one.

Excel

Formulas, named ranges, pivot tables, charts and formatting — with assertions that separate a calculated value from a typed-in one.

Essay

Rubric-based assessment with configurable strictness and per-criterion feedback rather than a single number.

Tableau

TWB and TWBX parsed for chart type, shelf fields, context filters, calculated fields and caption requirements.

Power BI

Two-layer PBIX parse — report layout and data model — with DAX measure validation. Mac students submit through a documented path.

Python

Sandboxed test execution, AST structure analysis, blocked-import guard and AI code review. Accepts .py and notebooks.

R

AI-first and tidyverse-aware. Grades without R installed on the server, so a missing runtime never blocks a batch.

Statistics

Numerical answers checked with tolerance, then method and interpretation scored separately. Tool-agnostic across R, Python, Excel and SPSS.

Access

Table structure, queries, forms, reports and relationships. ACCDB and MDB.

Generators

6 Each emits a rubric the matching grader can consume.

SQL assignments

Known schemas or your own, difficulty control, multiple versions, and a rubric the SQL grader reads directly.

Excel assignments

Task list, starter workbook and solution workbook, including Python-in-Excel tasks that return a matplotlib figure into the grid.

Tableau assignments

Skill profiles from beginner to advanced across 29 skills, with dataset management and Socratic instructor guides.

Power BI assignments

Four assignment types across 28 skills, reusing datasets across tools so a cohort sees the same data in three products.

Statistics assignments

Datasets engineered to have known coefficients and p-values, which is what lets the statistics grader mark method as well as answer.

Quiz and exam questions

Multiple choice, true/false, matching, fill-in-blank and essay prompts, exported in D2L quiz import format.

Content

Lecture material and walkthroughs, produced rather than recorded.

Tutorial engine Newest

Turns a marked solution into a staged video that runs at every step. SQL and Excel Online today; Power BI and presentations next.

Lecture Studio

Upload a deck, get a narrated video: AI writes the script, two voices read it with real pacing, and the renderer cuts it to a target length.

Presentation generator

Topic to outline to branded PPTX, with a fact-checking pass over the generated slides.

Image generation

An AI image generator wired into the slide pipeline — auto mode reads each slide and illustrates it — plus a standalone image library. The provider is configurable, so the pipeline outlives any one model.

Academic tools

The parts of teaching that are not marking.

Virtual teaching assistant In progress

Answers from your course materials only, with change detection when you update them. Students get in with an access code. Still being built — the rest of this list is running today.

AI oral exam

Interactive exams where the AI asks, listens, and follows up. Returns a scored transcript against your rubric.

Peer evaluation

Roster upload, teams, anonymous scoring, and PDF reports that flag score distributions and disagreements worth a look.

Integrity analyzer

Scores an assignment for how easily it can be completed by someone else — or by a chatbot — then hardens it on request.

Accessibility checker

PPTX, PDF, DOCX and HTML scanned against WCAG 2.1 and Section 508, with per-fix preview before remediation. Read the brief →

Plagiarism detection

Cross-submission similarity within a cohort, reported alongside the grading run.

Course materials hub

One course, term and section hierarchy shared by every module, with a 30-day recycle bin.

Query Forge In progress

A student-facing SQL sandbox with a tutor attached, so practice happens somewhere the course can see it.

Platform

Multi-tenant from the first line, not retrofitted.

Organizations

Per-department isolation with its own logo, colours and CSS, usage analytics and configurable quotas.

Choose the model per function

Anthropic Claude, OpenAI, or Ollama running locally. An admin picks which model powers each function, so essay grading and quiz generation need not share one.

Keys three ways

Organization-provided, bring-your-own, or billed through us. Service API keys carry scopes and expiry.

REST API

438 documented endpoints with interactive Swagger docs. Build your own front end, wire it into your LMS, or drive it from CI.

Sign-in

JWT, Azure Entra ID and Google. SAML and generic OIDC have a configuration interface; the backend flow is still landing.Partial

Delegation and audit

Consent-based TA delegation with scoped permissions, and a per-user action trail behind it.

Analytics and search

Grading trends, score distributions and storage use, plus Ctrl+K search across every content type.

Export everything

One-click ZIP of all of your content. Nothing here is a hostage.

Student data

Where the data goes, stated plainly

Real student work moves through this system. The honest version of our posture is below — including the part most vendors leave out.

What we do

  • Identifiers are stripped before any submission is sent to an AI provider. The model sees the work, not the student.
  • Isolation per instructor and per organization at the application layer, enforced on every route.
  • An audit trail of who accessed what, and automatic cleanup of temp files containing student work.
  • Deletion on demand — a grading job and everything it produced can be purged.
  • A fully local option. Point the platform at Ollama on your own hardware and no submission leaves your network.

What we will not claim

We describe the platform as FERPA-aligned, not FERPA-certified. There is no such certification to hold. Your institution should run its own assessment against its own deployment, and we will hand over whatever detail that takes.

When a cloud provider is selected, de-identified submission content is transmitted to that provider for evaluation. That is a real trade-off, it is why the local option exists, and it is set per function rather than once for the whole platform.

Database-level row security arrives with the PostgreSQL cutover. Today the isolation is enforced in the application, and we would rather say so than imply otherwise.

Recent work

What has landed lately

The platform is in active development. A sample of what changed most recently, so you can judge the pace for yourself.

  • Aug 2026 Agoge CourseOps — the whole stack, as a local install The graders and generators folded into a course development studio that runs as a container on an instructor’s own machine, against their own AI subscription. The same engines as the hosted platform — a different way to buy and run them. How the two compare →
  • Aug 2026 Staged SQL walkthroughs built from answer keys The tutorial engine decomposes a marked solution into the order it was written and re-runs it at every stage. Anything it cannot confidently take apart raises rather than guessing, so a lesson is never quietly built from a misparse.
  • Aug 2026 Two-voice narration with real pacing Teacher and student voices, length targeting, and a check that refuses to render a lesson whose on-screen number disagrees with the number it says out loud.
  • Aug 2026 Power BI grader and generator Ninth grader in the set, scoring the report layout and the underlying data model as separate sections.
  • Aug 2026 Saved work sessions A console shell with saved sessions, reusable profiles per module, and a recycle bin — so a long grading run survives closing the tab.
  • Aug 2026 Moved onto our own hardware The platform left managed cloud hosting for self-hosted infrastructure behind a Cloudflare tunnel. Lower cost, and a shorter path to an on-premise deployment inside a university network.
  • Aug 2026 Google Sign-In Alongside the existing Azure Entra ID and password paths.

Get access

Request demo access

We are in testing and giving access to departments and instructors willing to run it against a real course. Tell us what you teach and we will set you up with the modules that fit.

Thank you. We have your request and will be in touch shortly at the email you provided.

Stay in the loop

Release notes, occasionally

New modules and notable changes, sent when there is something worth reading. Not a drip campaign.