Plinth - Grounded Requirements Agent

• 

  Logo

The problem: AI build agents are only as good as their requirements

A new generation of AI agents can scaffold backends, write frontends, and generate tests. But they all inherit the same failure: if the requirements are wrong, they build the wrong thing, fast, and confidently. And requirements are exactly where software projects have always bled money.

So we tried the obvious thing: point an LLM at a stakeholder meeting transcript and ask it to write the requirements. It produced a beautiful, well-structured spec, for a generic login system. The transcript was about a laundromat. The model had quietly fabricated an entire product, complete with plausible sounding "requirements" nobody ever asked for.

That was the insight behind Plinth: the bottleneck isn't generating requirements, it's generating requirements you can trust. An agent that invents requirements is worse than useless, it's a liability wearing a suit.

What Plinth does

Plinth is a multi-agent system that turns a raw discovery transcript into a grounded, machine consumable requirements package, the foundation downstream build agents stand on. (A plinth is the base a column rests on.)

Its defining feature is a provenance integrity control that makes fabrication structurally impossible:

A requirement can only be marked confirmed if its cited quote is a verbatim substring of a real human source. Anything an agent infers can only ever be assumed or open - never confirmed - and the system refuses to certify a package as "ready for downstream" until that guarantee holds and a human has resolved every blocking question.

The output is a full artifact pack: requirements, personas, a domain model, user stories, open questions, decisions, a traceability matrix, and a handoff manifest - every human readable file rendered from a machine readable source of truth.

How we built it

The guiding principle is LLMs reason; deterministic code enforces the guarantees.

• Orchestration - a Google ADK SequentialAgent pipeline (intake → requirements → an actor-critic review LoopAgent → user stories → packaging), with shared state passed between stages.
• The models — Qwen models on Qwen Cloud, integrated into ADK through LiteLLM's OpenAI-compatible DashScope interface.
• The enforcement layer - a deterministic Python core (Pydantic schemas + validators) that the agents can't talk their way past. The grounding check runs as an ADK after_agent_callback: the LLM proposes a requirement; the callback verifies the quote exists in the transcript and demotes anything that fails. Status isn't the model's opinion - it's a consequence of grounding.
• The actor-critic loop - a QA-critic agent reviews each round for ambiguity and contradiction; the loop is bounded and exits on a clean pass, with residual issues surfaced as open questions rather than silently dropped.
• Packaging - the traceability matrix and manifest are computed from the records, never written by an LLM, so they can't drift.

What we learned

• Grounding has to be structural, not prompted. "Please don't hallucinate" fails. A validator that rejects an ungrounded confirmed at generation time does not.
• "Tests pass" is not "it works." Our unit tests were green while the live pipeline silently produced nothing - because they tested functions, not the regenerated artifacts. We learned to assert on the output pack, with a fresh generated_at timestamp as the tell for whether the pipeline actually ran.
• A false green is worse than a red. The hardest bug wasn't fabrication - it was the system declaring a package "ready" when it wasn't. Making readiness a computed consequence of grounding + coverage + resolved blockers, rather than a flag an agent could set, was the fix.

Challenges

The deepest one was a cross project contamination bug: a run on one transcript emitted another project's requirements, because a stage was reading a cached test fixture instead of the live input. Catching it required diffing generated requirements against the source transcript quote-by-quote - which, fittingly, is exactly the grounding discipline the whole system is built on. The bug that nearly sank us was caught by the guarantee we'd designed to prevent it.

What's next

Plinth is the first stage of an agentic build pipeline: grounded requirements feeding architecture, backend, frontend, QA, and planning agents downstream, each consuming the handoff manifest, each standing on the same verified base.

Built With

• actor-critic
• alibaba-cloud
• dashscope
• google-adk
• litellm
• llm
• mermaid
• multi-agent
• pydantic
• python
• qwen
• qwen-cloud