Agentic Apps · 04.02
App Goals: An App That Gets Better at Its Own Goal
Every other app is frozen the day it ships. Give an Agentic App a Goal and it runs competing strategies toward it, measures which one actually wins, learns that in its own Brain, and evolves — promoting the winner and breeding the next generation. Under your control, and without lying about the results.
Every other app is frozen the day it ships
A normal app is finished the moment it's deployed. Whatever approach its designer guessed at — the first message it sends, the order it asks its questions, the offer it leads with — is the approach it will still be running a year later, whether or not that approach actually works. Making it better means a human noticing, forming a theory, and shipping a change. The software itself never learns a thing.
An Agentic App is the first kind of software that doesn't work this way. You give it a Goal — a durable statement of what it's for, and optionally the one metric that defines "better" here (conversion_rate, resolution_time, whatever you're actually trying to move). From then on the App can try competing approaches, watch which one genuinely wins, remember that in its own Brain, and evolve toward the Goal on its own — continuously, under your control, and without ever inflating the results. This is the payoff the four pillars are building toward, so it leads the category.
A Goal is the tier above a run's objective
Be precise about the word. Everywhere else in Agentis an objective is run-scoped — the checked definition of done for a single run (see the Workflow Engine). A Goal is the tier above it: the north-star an App pursues across hundreds of runs, over weeks and months. One decomposes into the other — a Goal is what the App is trying to get better at; an objective is what one run has to finish.
You set it with agentis.app.goal. It rides in the App's manifest, so it travels with the App and can't be lost in a side config, and it's mirrored into the App's Brain as governing context — so every run recalls the Goal on its own, instead of being reminded of it by hand.
Strategies compete — and only outcomes count
A Strategy is one concrete way to pursue the Goal: open with a question versus lead with a demo video. Strategies don't take turns being someone's favorite — they compete. Each maps to an arm of an Experiment, each accrues a real record of wins and trials, and each earns a confidence that is a Laplace-smoothed win rate — (wins + 1) / (trials + 2). Win once out of one and you are not crowned brilliant; a small sample stays humble until the evidence arrives.
That formula is the whole point. The obvious way to build a learning loop — reinforce whatever pattern shows up most — quietly rewards a bad approach that merely runs often. Here, confidence tracks the outcome, never the frequency. And when a strategy is genuinely proven, it's written into the App's Brain as a recallable lesson, so the next run reaches for the winner without being told to. Author and inspect them with agentis.strategy.propose and agentis.strategy.list.
The loop, closed
Three capabilities lived in Agentis for a while as strong but disconnected arcs. The Evolution Loop is the wiring that turns them into a circuit that feeds itself:
| Arc | What runs |
|---|---|
| Measure | The Experiment primitive — sticky variant assignment and a per-variant success rate — plus rolling performance baselines captured on every terminal run. |
| Learn | The moment an experiment outcome is recorded, it bridges into the App's Brain: the strategy for that arm counts the outcome, outcome-weighted. The two systems that never used to touch now do. |
| Evolve | A controller reads the standings, decides whether there's a real winner, and then promotes it, retires the clear losers, and calls for the next generation. |
The difference is direction. An A/B test used to end in a number a human had to read and act on. Now the result feeds forward on its own — it changes what the App recalls and reaches for the very next time.
It cannot lie about a winner
The controller that declares winners is deliberately hard to fool. Each competing arm needs a minimum sample, and the leader has to beat the runner-up by a real margin and clear a two-proportion z-test at roughly 95% before anything is called a winner. Short of that it says no_clear_winner and lets the arms keep running — an early lucky streak can't lock the App onto the wrong approach.
When there truly is a winner, it's promoted (its recall weight rises), the significantly-worse strategies are retired, and the App is told to breed the next generation from the winner. That last step is a recommendation, not a hidden model call: the promote/retire decision stays deterministic and tested, while the owner agent writes the new variants via agentis.strategy.propose. And none of it happens behind your back — a cadence sweep reviews continuously, but acting automatically is operator-gated and off by default. Left alone, the loop only surfaces proposals; you decide. Trigger a review yourself with agentis.evolution.review (apply: true to act).
The Goal dashboard: the whole loop in one honest read
One request shows you everything. GET /v1/apps/:id/goal returns the Goal, every competing strategy with its live win rate and confidence, the running experiments, the performance baselines, and the controller's current promote / retire / spawn recommendations — all computed from measured outcomes at request time, never a stored claim. The App engine renders it as a Goal tab: north-star, standings, and the verdict per experiment. What you see is what actually happened — the same honesty rule the rest of Agentis holds to.
Continue
Not a chatbot, not a script, not a SaaS app with an AI feature bolted on. An Agentic App is durable software built from four real pillars — data, interface, orchestration, and its own Brain.
One end-to-end walk through what actually exists in the database and who touches it — from build_workflow to a staffed, data-backed, self-orchestrating product.