---
site: "zyx.tw"
title: "AIntern"
description: "AIntern: an AI intern for any team."
url: "https://www.zyx.tw/project/aintern"
---

# AIntern

An AI intern for any team.

Office work is full of forms, checks and sign-offs. In AIntern, a person describes the work in plain words, and an agent builds it as a workflow on a live canvas.

The agent tests each step as it adds it. Where the result matters, a review stops the run until a person reads it and approves.

Each organisation runs its own instance, with its own accounts, rules and budget.

## How it works

A workflow goes through 5 steps. People do the first and the fourth, the agent does the 2 between them, and the last one repeats for as long as the work does.

```text
╭────────╮   ╭────────╮   ╭────────╮   ╭────────╮   ╭────────╮
│  SAY   │──>│ BUILD  │──>│  TEST  │──>│ REVIEW │──>│  RUN   │
╰────────╯   ╰────────╯   ╰────────╯   ╰────────╯   ╰────────╯
 a person     the agent    the agent    a person     a trigger
 in words     on canvas    each step    signs off    or button
```

Figure: Five steps in a row: a person says the work in words, the agent builds it on the canvas, the agent tests each step, a person signs off, and a trigger or a button runs it.

1. Say: You describe the work in the chat, as you would to a new colleague.
2. Build: The agent adds nodes to the canvas and connects them.
3. Test: It runs each step with real input and fixes what fails.
4. Review: The run stops here until the named person approves.
5. Run: From then on a schedule, a form or a button starts it.

## Build

You say what the work is, in the chat beside the canvas or from your own agent over MCP. Nodes appear on the canvas as the agent adds them.

Technical choices are the agent's. Business rules are yours: who approves, what counts as an exception, who is told. When a rule is open, the agent asks in a card and waits for the answer.

Every change is a version, so an earlier state is one step back.

![A leave request workflow of 5 nodes on the canvas, in Chinese. In the chat below, the agent has added 3 steps and reports its test.](https://www.zyx.tw/works/aintern/build.webp)

## Nodes

A workflow is a graph of 10 kinds of node. Rules that must give the same answer every time go in Python. Models only read and write text.

- Start: Says how the workflow starts and what it takes in.
- Python: Runs a function in a sandbox, with files, a browser or office documents.
- AI: A model reads and writes, at one of 3 tiers, with tools and web search if it needs them.
- Review: Stops the run until the named people approve.
- Branch: Sends the run one way or another by a rule.
- For each: Runs the steps after it once per item in a list.
- Wait: Pauses for a duration or until a time.
- Table: Keeps rows from one run to the next.
- Google: Reads and writes Docs, Sheets and Slides.
- End: Returns the result, sends it, fills a form or publishes a page.

## Review

A review goes before any step that changes something for people: a form submitted for someone, mail to the outside, money.

The reviewers are people or groups, and the rule is any of them, all of them or a count. A reviewer can correct the data, or send the run back to an earlier step with a comment.

Only a person in a browser can approve. The agent cannot, and neither can a token or an MCP client.

![A review card in Chinese shows a leave request with Send back and Approve. 2 of 3 reviewers must approve, and 1 has.](https://www.zyx.tw/works/aintern/review.webp)

## Starts and ends

A workflow starts 6 ways and ends 5 ways. The same workflow can sit behind a form for the whole office, or run every Monday at 9.

```text
 STARTS                                      ENDS
 a person presses Run ─╮                  ╭─ a result page
 a schedule ───────────┤                  ├─ an email
 an incoming webhook ──┤  ╭──────────╮    ├─ a webhook call
 mail to its address ──┼─>│ WORKFLOW │───>┤
 a web page or form ───┤  ╰──────────╯    ├─ a filled form
 the Chrome side panel ╯                  ╰─ a published site
```

Figure: Six starts lead into a workflow: a person presses Run, a schedule, a webhook, mail to its own address, a web page or form, the Chrome side panel. Five ends lead out: a result page, an email, a webhook call, a filled form, a published site.

1. Starts: 6 things start a run: a person, a clock, another system, a mail, a web page or the browser's side panel.
2. Workflow: The same workflow runs, whatever started it.
3. Ends: The result goes where it is needed: a page, a mailbox, another system, a form or a published site.

## Team

The agent's instructions come in layers: a neutral core, then the organisation's own rules, then the rules of each group the person belongs to. So it uses the team's words and knows the team's systems.

Groups form a tree. A workflow is shared with people or groups as viewer, runner, editor or owner, and a copy can pull changes from its parent or offer its own back.

People sign in with a passkey, by invitation, or with the organisation's single sign-on. Spending has a monthly cap for the site and for each person, and the audit log cannot be edited.

![4 rules from 3 layers on the left, in Chinese. On the right, a reply in the chat, with the words one rule changed lit.](https://www.zyx.tw/works/aintern/team.webp)

## For agents

What a person can do on the page is a tool in one registry of 91. The chat agent and MCP clients such as Claude Code and Codex call the same tools, with the same permissions.

22 of them work on the page only: accounts, permissions and the agent's own instructions stay with a person.

## How it is built

The web app holds the canvas, the chat, the tools and the scheduler. Work runs in 3 kinds of runner: Python, a browser (Playwright) and office documents (LibreOffice and OCR).

Runners pull jobs from the web app and never reach the database. Each job runs in a new sandbox with a private temporary folder and no privileges.

Credentials are sealed at rest and masked in every log. The model is the Claude API or any OpenAI-compatible endpoint, chosen in configuration.

```text
 browser      Chrome panel      Claude Code, Codex
    │              │                    │ MCP
    ╰──────────────┼────────────────────╯
           ╭───────┴──────╮      ╭──────────────╮
           │   WEB APP    │──────│   POSTGRES   │
           │   Next.js    │      ╰──────────────╯
           ╰───┬──────┬───╯
          jobs │      │ models
   ╭───────────┴──╮ ╭─┴─────────────╮
   │   RUNNERS    │ │     MODEL     │
   │  Python      │ │ Claude API or │
   │  Playwright  │ │ OpenAI-       │
   │  LibreOffice │ │ compatible    │
   ╰──────────────╯ ╰───────────────╯
```

Figure: A browser, the Chrome side panel and MCP clients reach the web app. The web app stores state in Postgres, hands jobs to three runners (Python, browser, documents) and calls a model: the Claude API or an OpenAI-compatible endpoint.

1. Clients: People use the browser or the Chrome side panel. Agents come in over MCP.
2. Web app: One web app holds the canvas, the chat, the tools and the scheduler.
3. Postgres: State lives in Postgres. Only the web app talks to it.
4. Runners: Runners pull jobs and run each one in a fresh sandbox.
5. Models: AI steps call one model, the Claude API or an OpenAI-compatible endpoint, chosen in configuration.

## Details

- Site: [https://aintern.zyx.tw](https://aintern.zyx.tw)
- Built with: Next.js, Postgres, Docker runners, bubblewrap, MCP, Passkeys, OIDC

Back to [Project](https://www.zyx.tw/project.md).
