Skip to content
runward
runward
Product
Who it is for
Trust
Documentation
News
Try it on an example Talk to us

runwardProductWe use it ourselves

We use it ourselves.

Our own products are subject to the same check as yours. Each at its own level, from the strictest to the most flexible.

During developmentBuilt with runwardWhat the check stoppedrunward in the product

During development

What our own agents say about it.

Our products are built by AI agents. Here, in their words, is what runward changes while they work. Each house’s own rules are not counted here.

The agent of our internal tool

Our agent reads the decisions and builds against them; nothing merges or deploys until what is required has its evidence.

The decision on the forge connection was written, reviewed three times adversarially, accepted, then built point by point: each of the sixteen points of its review has its test. The repository is public.

The agent of Dropyour

“After a break, the agent does not start again from its memory: it rereads the written decisions, what they forbid and what it must prove, and a commit that breaks a sealed piece of evidence is refused.”

Before a new stage, three written decisions told it what was forbidden, and did the design in its place. Surveying what existed before writing the decision showed that a planned instruction was wrong: the stage was recut with the author before the first line of code.

Its limit, in its own words: runward keeps the trace and the seal; the tests prove the behaviour.

The agent of our watch tool

“runward stops me from endorsing my own work alone: six deviations I had justified myself blocked the check until the decisions were endorsed.”

And the rule held: a change of sign became a new decision.

The agent of Hitpoint

“I never start from scratch and I do not decide alone. What is decided is written, and what is not, I ask.”

Built with runward

Four products, three levels.

The same check, set according to what each product commits.

  • 01Blocking, end to end

    Dropyour. Before each commit, the check refuses a commit whose sealed evidence changed without being checked again. Our merges go through a script of our own that merges only on a green verdict. Each structuring decision is written before the code, and the merge endorses it. More than 560 written decisions.

    Our internal tool, the runward app, in a public repository. The check is required to merge, and the chain neither pushes nor deploys any image until the verdict is green.

  • 02At every push, followed in our internal tool

    Our watch tool. Each structuring decision is written and checked before it ships: without an endorsed decision, the check refuses. The verdict of each version of the code and the decisions goes to our internal tool on its own, which says whether something blocks, without reading the delivery chain.

    Several agents work in parallel on the same repository; only one writes the decisions, and the check holds the line. The decisions of the Another Framework site live in this repository and go through the same check.

  • 03Decisions first

    Hitpoint: each decision that commits the product is written, dated and endorsed before it counts as done.

What the check stopped

Real stops, in our own work.

The repositories of Dropyour, of our watch tool and of Hitpoint are private: these stories have no link. The one of our internal tool is public.

Dropyour, a sealed piece of evidence

A commit touches a sealed document without checking it again. The check refuses it, with the reason “sealed evidence changed”. The document is reread, then sealed again.

Our watch tool, 10 November

An agent had declared deviations from the checklists (security, resilience, performance, observability) resting on decisions still at the hypothesis stage. When strict mode came in, the check refused: a deviation that rests on no endorsed decision is worth nothing. The decisions were reread and endorsed, then the check went green.

Our internal tool: 17 claims refused out of 42

runward in the product

What our products do with runward for their users.

Dropyour

Your AI builds; runward makes its work verifiable: on request, a system of apps delivers its link contracts, and an app with a server can deliver its proof dossier, which you or your client replay without us.

The Another Framework studio

Our rule: when our agents build the app that a signal has pointed to, nothing goes live because an agent says it is done: runward checks each version against the decisions and the evidence, and says what blocks.

  • 01A proof dossier, re-checkable without Dropyour

    An app with a server can be delivered with its runward proof dossier: the mission, the seal and the verdict, the served code and its digest. Its owner, its client or its auditor re-checks it without Dropyour and without an account, with runward verify.

  • 02The verdict, read by your AI

    Your AI reads the latest runward verdict from your app’s proof dossier, and it shows in the cockpit.

  • 03Your app’s decisions, written by your AI

    For an app with a server, your AI writes your app’s decisions, and runward checks them in its proof dossier.

  • 04Contracts the client judges for itself

    The contracts between linked apps export as a runward specification, which the client judges with npx runward spec-check.

  • 05The mission in the dossier

    The proof dossier of an app with a server contains its runward mission.

  • 06The studio’s rules, checked

    The rules of the studio’s method are written decisions checked by runward: a rule changed without an endorsed decision is refused.

Try it on an example, in one command.

Try it on an example

Talk to us

Tell us who you are, and we will get back to you.

Your details are recorded by Another Framework, publisher of runward, to get back to you. They are neither sold nor shared, and are deleted three years after our last exchange. To see or delete them: contact@runward.dev.