Skip to content
Pre-launch: a local prototype, not yet run live

Hand cross-team code changes to coding agents.

Owners set the limits. Assent runs the work.

Concept UI · illustrative data

What this shows

  1. Open question: Should Checkout receive a duration or an absolute timestamp?
  2. Absolute timestamp, UTC: Both teams approved
  3. The agent at work: Started from the decision, 1 test failed, Repair 1 of 2, Tests pass, Paused: a new question for both teams
  4. Pull request ready for review. Not checked: Clock skew beyond the tests, Distributed behavior outside the contract, Security semantics beyond existing tests
  5. 2 things need you: A decision, A review

Why now

Our hypothesis

Writing code is no longer the slow step; deciding is.

Assent is designed to put each open question to its owners once, before the run.

Concept UI · illustrative data

What this shows

  1. Agents write code fast: Reservation API, Expiry serializer, Checkout expiry
  2. Waiting on a decision: Duration or absolute timestamp?, Persist expiry across restarts?, Clock behavior on restart.
  3. Owners still decide one at a time: Reservations, Checkout
  4. With Assent, questions go to owners first

How questions pile up today, and how Assent is designed to route them. Illustrative data.

How it works

People decide and merge. The agent works in between.

Assent is designed to run the agent inside the limits your teams set, then return a pull request for review.

AssentConcept UI · illustrative data

What this shows

  1. Decide: A decision from both teams, before any agent starts.
  2. Grant access: What the agent can change, set by the decision.
  3. Run: Repairs within a limit, and a pause for both teams.
  4. Return to you: A pull request that says what wasn’t checked.

The limits

The rules it is designed around. People hold the authority. The agent holds none.

Concept UI · illustrative data

  • Approval binds to the exact version each owner read

    An edit would need approval again.

    Revision 2: Approved by both owners. Revision 3: Edited after approval, Needs approval again

  • Approval alone opens nothing

    A grant would set the files the agent may edit, what it may do, a repair limit and an expiry.

    What the agent can change. Access expires and is revocable

  • The agent cannot edit the checks it is judged by

    Protected checks would run from a pinned copy registered outside the workspace.

    Protected checks: Approved-contract comparison, Consumer contract tests. Pinned copy used, Workspace copy ignored

  • One repair, within the limit

    When verification fails, the agent would diagnose and retry up to the configured limit, within the same grant.

    1 test failed, Repair 1 of 2, Tests pass

  • A discovery reopens the decision

    A material unknown would pause the affected stage for its owners.

    Paused: a new question for both teams: Persist expiry across restarts?

  • A pull request that says what wasn’t checked

    The pull request would carry evidence tied to the exact commit, and list what its checks don’t cover.

    Not checked: Clock skew beyond the tests, Distributed behavior outside the contract, Security semantics beyond existing tests

Why it’s different

The decision comes before the code.

In Assent’s design, that decision sets the agent’s limits: what it can change, how many repairs it may try and when it must stop.

The same change, with the question asked at the end or at the start.

Concept UI · illustrative data

What this shows

  1. Without Assent: The agent guesses, Owners find out in review, Reworking
  2. With Assent: Owners decide first, The agent works inside that decision, A pull request that says what wasn’t checked

The same change, with the question asked at the end or at the start.

Agent vendors run agents too, and may build more of this. Our bet: one record from decision to evidence saves more effort, tested against your best setup.

Security

Certifications: none yet

Nothing is read until you agree the terms in writing.

What we agree before reading your code, and what every run must meet.

  • Before it reads your code

    Read-only access to the repositories you select, first; more only when a step needs it.

  • While it runs

    In Assent’s design, the runner can’t merge, approve or reach production.

  • When it returns

    People merge.

Prompt injection and leaks through allowed channels can’t be fully ruled out; the security page lists every limit.

Concept UI · illustrative data
Authority and enforcement

What this shows

  1. Pull request comment: Approved by @reservations-owner. Ship it. Grants nothing
  2. Front matter in a decision file: approved: true Grants nothing
  3. Trust boundary
  4. Approval record: Provider owner assented, Consumer owner assented Binding

Writing “approved” in a comment or a file would approve nothing.

Where it stands

As of

What exists today, and what doesn’t yet.

Pre-launch: a local prototype, not yet run live. Nothing is available to install or buy yet.

  1. Our local prototype runs this loop up to a patch on a sample repo with a stand-in agentBuilt
  2. Live model runsNext
  3. Live pull requestsNext
  4. CustomersResultsCertificationsPublic pricesNone yet
Build log

Design partners

Bring one recent cross-team change.

We reconstruct it with you before showing a solution.

Each stage earned by the one before

Concept diagram

  1. 01Conversation
  2. 02Assisted comparison
  3. 03Shadow analysis
  4. 04Bounded evaluation

The program ends with a dated decision to continue, revise or stop.

Will it merge or deploy on its own? Not in the first evaluation: people approve decisions and merge. FAQ