Paitite Research

AI agents now write software. We work on keeping people in charge of it.

Paitite Research is an applied lab. We study what it takes to control, verify and understand code written by AI agents, and we publish what we learn as open-source tools and field notes.

Read the research agenda See the projects

Questions we work on

Why now

Coding agents can produce change faster than people can review it.

Code review was the safety net, and it does not grow with output. The common answer is to put a second model in front of the first one and ask it whether the work looks right. We take a different route. A claim about a change should come from the change itself: the real diff, the real tests, the real files in the project. When that evidence is thin, a tool should say so.

Research areas

Full agenda

  • Agent control and safety

    Coding agents run commands, install packages and edit files on real machines. Most of what they do is fine, and a guardrail that interrupts constantly gets switched off. We work on controls that stop a short list of clearly dangerous actions, record the rest honestly, and leave the final say with the provider's own permissions and the people using the agent.

    3 charted 1 surveying 2 uncharted

  • Verifying AI-written code

    A passing test suite says that a patch passes. It does not say which parts of the patch the tests depend on, or whether the new tests would have caught the bug at all. We build counterfactual experiments on the real diff and report what they show, including when they show nothing.

    5 charted 3 uncharted

  • Human legibility of AI work

    When an agent writes most of the code, the risk is not only bugs. It is a team that no longer knows how its own product works. We study explanations that are tied to what was actually observed in the project, that name real files and real dependencies, and that admit when they do not know.

    4 charted 1 surveying 2 uncharted

Projects

Open source, MIT license

DiffWitness

A local control layer for code written by AI agents. Public alpha.

It can optionally block a short list of high-confidence dangerous agent actions. It runs counterfactual experiments to show which parts of a diff the tests really depend on, and keeps a verifiable ledger of the obligations a change leaves behind. It runs on your machine, with no model API, hosted account or source upload.

IdleProof

The human-understanding layer for agentic coding.

It watches what a coding agent is doing and explains the change in plain language: what it does, where it lives in your project and what could go wrong. It uses your real file names and says when the evidence is thin.

More about the projects

How we work

  • Claims come from evidence. A statement about a change should trace back to the diff, the tests or the files, not to another model's opinion.
  • Unknown stays unknown. Observed, inferred and inconclusive are different things, and our tools label them that way.
  • Local first. Core analysis runs on the developer's machine, without a hosted account, a model API or uploading source code.
  • We say what we have not measured. Our agenda shows what is charted, what we are still surveying and what remains uncharted.

Notes

All notes

  • Unknown should stay unknown

    Tools that report on AI agents are tempted to round thin evidence up into confident statements. We think the labels matter more than the summary.

  • What a test run can and cannot say about a patch

    A green test suite tells you the patch passes. It does not tell you which parts of the patch the tests depend on. Counterfactual runs can.