Architectural control for AI coding agents

Is your coding agent making architecture decisions you never approved?

AI coding agents are no longer just writing code. They choose patterns, create abstractions, move boundaries, and make tradeoffs that the rest of your project quietly builds on. That is powerful. It is also dangerous.

Meetless gives you a control plane for AI coding agents. It keeps them grounded in your approved architecture, rules, and past decisions, surfaces the decisions they make each session, flags contradictions, and lets you decide what becomes project truth for future runs.

Built for developers and solo founders using AI coding agents to ship real products.

You are still the architect.Nothing your agent proposes becomes project truth until you approve it.

Claude Code today  ·  Dogfooded daily  ·  Founder-led private beta

Raw dogfood note

This is early. I am the first user. I am coding with AI agents every day and using mla to govern that workflow. The scars here are real: agents lost decisions across sessions, reintroduced killed patterns, and crossed boundaries I had drawn. mla exists because I needed a way to control what my agents remember before their work became my codebase.

An Pham

An Pham

Founder, Meetless

The control loop changed

Coding agents move faster than your control loop.

Senior engineers used to stay in control by reviewing code, guiding architecture, and catching bad tradeoffs early. That worked because humans wrote at human speed.

Now one agent ships a feature in an afternoon, and several run in parallel. Each can make a choice that looks reasonable locally but violates the larger system. The failure mode is no longer just bad code. It is bad foundation.

An agent can:

  • half-build an important feature in the wrong place
  • reuse a pattern you already banned
  • disable a standard to make the build pass
  • duplicate an existing capability under a different name
  • make a local tradeoff that conflicts with the product direction
  • carry stale context from a previous run
  • invent a decision and treat it as settled truth

By the time you notice, the mistake may already be spread across the codebase. Meetless exists to catch that earlier.

Tests are necessary, not control

Architecture and test coverage are not enough.

A test suite can pass while the agent violates your architecture. A typecheck can pass while it builds the wrong abstraction. A pull request can look clean while a workaround quietly hardens into a permanent standard.

What tests answer

Does the code work?

What actually matters

Did the agent make the right decisions while producing it?

Most teams have no system for that. They rely on scattered docs, long prompts, CLAUDE.md, code review, and the memory of whoever is supervising the agent. That breaks down the moment agent work becomes continuous, parallel, and high-volume. Meetless gives you the missing layer between prompts and code review.

Ground

Keep agents grounded in project truth.

Architecture is not a one-time decision. It is constant steering: when to keep a pattern, when to kill one, when to bend a rule, when to migrate, when to accept debt. Coding agents do not naturally carry that context, and even when they have some of it, they do not reliably know which parts matter right now.

Meetless keeps a coordination graph of your project truth:

  • architecture decisions
  • rules and policies
  • killed patterns
  • accepted tradeoffs
  • rejected approaches
  • business logic
  • internal tools
  • relationships between prior work

Before an agent acts, Meetless briefs it with the relevant parts of that graph. Not every note. Not every document. Only the rules and decisions that apply, each tagged with its source and its authority.

context injected into your agent
<meetless-context kind="first-run">
  grounding for the coding agent; verify against the codebase
  <confirmed-rules>
  <rule source=".cursor/rules/import-at-top.mdc" authority="must-follow">
    Always import at the top of the file.
  </rule>
  <rule source="apps/control/CLAUDE.md" authority="must-follow">
    Uses the outbox pattern; never executes side effects directly.
  </rule>
  <rule source="apps/control/CLAUDE.md" authority="must-follow">
    Trust Prisma. Do not hand-roll migrations.
  </rule>
  <rule source="apps/control/CLAUDE.md" authority="must-follow">
    Always use constant-time comparison for secrets.
  </rule>
  <rule source="apps/connector/CLAUDE.md" authority="should-follow">
    Use apiErrors.* factory functions for errors.
  </rule>
  </confirmed-rules>
</meetless-context>

You do not paste this in. Meetless injects it into your agent automatically at the start of every session. Real structure, trimmed to a few rules, assembled from your approved project truth.

Console: every decision your agents made, each captured with its rationale and status.

Surface

Surface the decisions your agent is making.

Agents decide constantly, and most of it stays hidden inside implementation steps:

namingdependenciesabstractionsboundariesdata modelshortcuts

Some are harmless. Some should become project truth. Some should be rejected immediately. Meetless captures and surfaces the decisions that matter from each session, so you inspect them directly instead of reverse-engineering them from terminal logs and diffs.

The agent can propose, implement, and explain. But only you decide what becomes durable project truth.

Flag

Flag contradictions before they snowball.

The most expensive agent mistakes are not syntax errors. They are contradictions:

  • this session violates an approved architectural decision
  • one agent builds against a pattern another session rejected
  • a new implementation conflicts with an existing rule
  • a workaround is being promoted as a standard
  • two parallel sessions solve the same problem in incompatible ways

Meetless checks agent decisions against your coordination graph and your other sessions. What contradicts approved project truth gets flagged. Everything else stays out of your way. The goal is not more review. It is better review: only the decisions that can damage future work.

Console: a flagged contradiction, with the two conflicting claims and their evidence side by side.

Approve

Approve what future agents are allowed to inherit.

Raw agent output should not automatically become memory. That is how bad assumptions become permanent. When an agent proposes a new decision, rule, pattern, or constraint, you decide whether it joins the foundation. Approve it and future agents are grounded by it. Reject it and it never pollutes your project truth.

1

Brief

Automatic

Ground the agent with the project truth that applies to this task.

2

Capture

Automatic

Record what the session actually did, decision by decision.

3

Surface

Automatic

Lift the meaningful decisions out of the diffs and logs.

4

Flag

Automatic

Check them against approved truth and raise the contradictions.

5

Approve

Your call

You decide what future agents are allowed to inherit.

You never run any of this by hand, and you never have to remember to. Meetless is mostly silent. When your agent notices it has leaned on decisions that are still pending review, it surfaces them in your normal flow and asks only when your judgment matters. You give the verdicts in plain language, or open the dashboard. That is how you scale agent work without surrendering architectural control.

claude code session
claude code
⏺ done. rate limiter is wired into the auth middleware and tests pass.
 
Before we move on: 2 decisions I leaned on this session are
still pending review (not trusted by default). Pulling them up.
 
⏺ mla kb review
 
  [CONTRADICTS] note:notes/auth-redesign.md -> note:notes/session-model.md
    referenced 5x this session   conf 0.86  ontology
    "sessions expire after 24h" vs "sessions stay valid for 30 days"
    id rc_8f3a21
 
  [REFINES] note:notes/onboarding-copy.md -> note:notes/db-indexing.md
    referenced 2x this session   conf 0.41  ontology
    "welcome email subject line" vs "composite index on tenant_id, created_at"
    id rc_2b9c04
 
The top one is a real conflict worth keeping; you leaned on it
most. The second looks spurious (unrelated docs, low confidence).
 
Review with me here, or open the dashboard:
  app.meetless.ai/sessions/sess_4f2a
 
you
keep the first, drop the second
 
claude code
⏺ mla kb review rc_8f3a21 --accept
accepted relationship candidate rc_8f3a21 (now ACCEPTED).
 
⏺ mla kb review rc_2b9c04 --reject
rejected relationship candidate rc_2b9c04 (now REJECTED).

Your agent surfaces this on its own, when it notices it has leaned on decisions that are still pending review. It pulls them with the real mla kb review, ranks them by how much this session used them, and recommends a verdict. You co-review here or open the dashboard, and only what you accept becomes project truth.

Console: ask a question about your project history and get a cited answer.

Ask

Ask your project what already happened.

Meetless is not only a review surface. Ask questions about past decisions, events, and architectural history directly from your coding agent or the Console:

  • Why did we reject this pattern?
  • Which sessions touched this subsystem?
  • What decisions govern this part of the codebase?
  • Did we already build something like this?
  • What rules should the agent follow before changing this module?
  • What contradictions are still unresolved?

Your project history becomes usable context, not buried terminal scrollback.

How it plays out

Three situations Meetless catches.

01

The strict mode trap.

An agent hits a TypeScript build error and disables strict mode to move forward. The build passes. Tests pass. The agent reports success.

But that was not an architectural decision. It was a shortcut.

Meetless surfaces it as a proposed decision. You reject it. Nothing is written to project truth, and future agents never inherit the workaround as a standard.

02

Killed patterns stay killed.

You ban a fragile database filter after it crashes production, and that decision becomes approved project truth.

A later Claude Code session works on a related query path. Before it acts, Meetless reminds it of the rule: do not use that banned filter.

If the agent reaches for the pattern anyway, the contradiction is flagged. The mistake is not rediscovered every week. The project remembers because you approved what mattered.

03

Parallel agents stop drifting apart.

You run multiple sessions against the same product area. One introduces a new naming pattern, another builds the same capability with different terms, a third adds conflicting logic.

Individually each looks reasonable. Together they create architectural debt.

Meetless tracks the sessions against one coordination graph, surfaces the conflicts, and lets you resolve which direction becomes the foundation. That is the difference between using agents and governing them.

Why this exists

Built from real agent scars.

  • An agent half-built an important feature in the wrong abstraction.
  • An agent reused a forbidden pattern that had already caused production damage.
  • An agent disabled a standard to make a build pass.
  • An agent duplicated an existing feature under a different name.
  • A memory extraction hallucinated a Jira issue from an internal branch label.
  • A review step verified an agent's claim using only the agent's own claim.
  • Decisions from one session failed to carry into the next, so the same architectural debate repeated.

These are not theoretical AI safety problems. They are daily software engineering control problems.

The job that does not go away

You are still the architect.

AI coding agents are becoming essential. They will write more code, take on larger tasks, and run in more parallel sessions. That is not going away. But fast implementation does not remove the need for architectural judgment. It makes that judgment more important.

Meetless lets you regain the control you had before agentic coding changed the speed of software development.

You are not driving one car anymore. You are supervising ten. Meetless gives you the control plane.

Private beta

Get architectural control over your agents.

Meetless is opening a founder-led private beta for developers using Claude Code in serious product work. It is hands-on: I will help you wire it into your workflow, show you where your agents are drifting, and shape the product around real usage.

No pricing yet. Private beta is free while we learn with early users.