Beyond Proposals Pt. I: Automation and the Art of Not Governing

Every transaction once required a governance proposal. Now they can execute according to rules governance defines but never has to touch again.

Last year, we planted our flag in the sand: if one-size-fits-all decentralized governance frameworks did not get replaced with something that could more flexibly adapt to real business needs, decentralization efforts would come to a halt. That’s now what we are seeing in the industry. 

Governance frameworks have been dependent on proposals, which treat every action as what is effectively an onchain referendum. They require a quorum of stakeholders to evaluate and approve any calldata prior to it becoming executable. 

This is not the right tool for all tasks. Imagine in the real world if every action taken by an organization was treated as a new decision - every time your company paid rent or payroll, allocated operational budget, rebalanced investments, or topped up a vendor account. Treating every recurring action as something new would force humans to reevaluate what is effectively an implementation of a decision already made. 

Humans should weigh in on decisions that actually demand human judgment: when the path forward is unclear, when stakes are high, or when intent must be expressed. But the operational reality of organizations is not one of novelty; it is repeated, structured, and predictable. 

This is why we believe the next step for onchain organizations is to identify where human intent does not need to be reevaluated and yet action still needs to be taken. Once an organization defines the “policy” that sets the rules for repeat transactions, the system itself should run them with no discretionary involvement or trusted intermediaries. This is what we are building at Aragon.

These policies live inside a new class of policy plugins. Just like our existing governance plugins, they control what can get executed. But unlike governance plugins, they do not require input to run.

• Operations are lean, deterministic, and transparent: Capital flows become predictable. Every transaction happens for a defined reason, with standardized accounting, and executes according to the organization-wide policy. Trust is gained through determinism.
• Discretionary decision making where it matters: Proposals won’t disappear; they’ll just be used for the exceptional, such as protocol upgrades, unexpected expenses, or even defining or changing policies. Human attention should be given to strategic questions that coherently drive the project forward.

Rise and fall of proposal-based governance

Onchain organizations are arbitrary executors: smart contract accounts capable of calling any function on any contract. That unbounded call surface is powerful, but it comes with a problem of expression of intent: the calldata structure is highly variable across protocols with inconsistent ABIs and it is often difficult to interpret.

The system needs an immune response to this novelty. That’s why, before any action is executed, there must be a discretionary evaluation of whether the calldata is aligned with the organization’s interests and stakeholder preferences. This is where proposals entered. A proposal packages the calldata with a human-legible description and gives time for stakeholders to vote.

Proposals made it safe for organizations to execute arbitrary calldata, but, as proposal volume scaled with organizational activity, human attention did not. 

This asymmetry becomes a structural incentive misalignment that puts early founders issuing governance tokens between a rock and a hard place. On one hand, founders and councils on small multisigs have incentive to move discretionary control to token holders. The concentration of discretionary control in just a few hands is a liability and can be a determining factor in an asset’s legal classification. On the other hand, at a time when product and protocol work is most convex, they are rightfully cautious about the costs of decentralization.

Even in the ideal token-based voting system, the median token holder has negligible influence and no direct benefit for paying attention and understanding what they’re asked to vote on. This is the classic paradox of voting: participation collapses because the mechanism gives them no inherent incentive to. 

This low participation makes the project prone to capture; value starts to leak to extractive entities with clever initiatives, project charters, new committees, and digital bridges to nowhere.

The past solution has been to glorify and gamify governance participation, predominantly by centralizing token voting onto delegates for direct compensation. This incentivizes them to engage in performative preference signaling to gain more delegations rather than accruing value to the actual token that has been delegated to them.

Governance becomes its own perverse economy.

Decision as policy

The governance surface should be intentional and pragmatic - centralized when appropriate and decentralized when onchain incentives align. The dilemma has been that not every decision falls neatly into those categories. 

But there’s a way out: proposals are not the only way an organization can take actions onchain. They should be reserved for only the genuinely novel, discretionary decisions - the kinds of decisions that need a continuous reencoding of human intent. When discretion isn’t required, proposals aren’t necessary.

It’s true that early on everything on the blockchain was novel and needed more heavy-handed decision making. But each ERC-20 transfer, burn, buyback, and repeated step in a treasury workflow get us closer to predictability. Interactions stabilize. What was novel became standard.

When action types are known and conditions are clear, decisions should only have to be made once. That can become the organizational onchain policy.

A policy is a set of rules for a known, bounded action type that allows an organization to act repeatedly without redeliberating stakeholder intent.

Policies are configured up front then applied automatically. Proposal-based governance is only needed when stakeholders want to update or replace that rule.

Policy design is thus an art of not governing.

Policy plugins in OSx

Aragon OSx is a neutral smart contract execution environment and plugin system. It centers around a single smart contract account (DAO.sol): an arbitrary executor with a dedicated ACL. It can be sent an array of “actions” which will execute if authorized. It doesn’t decide anything else - it just follows instructions.

These actions come from plugins: contracts that contain the decision logic to ensure what gets executed represents the organization’s interests or preferences of its various stakeholder groups. Plugins are composable and the primary unit of OSx’s modular design.

We are now splitting plugins into two categories:

• Governance plugins (e.g. TokenVoting, LockToVote, Multisig, etc.) handle proposal-based decision making. They gather many preferences and aggregate them into a single decision.
• Policy plugins exist for the opposite case, when preferences have already been expressed and decisions made such that actions can be repeated within the bounds of the policy’s settings.

Policy plugins are simpler than governance plugins. Their deterministic nature makes them easier to reason about.

• It has one job: execute a specific type of action, like sending funds to a set of addresses. 
• It has one logic: check the current state, and if conditions match, compose the calldata to submit to the executor. 
• It has one set of settings: determine how to calculate these parameters of the action (i.e. who gets paid, how much, and when). These values are political. Running the rule is not.
• It has the ability to update those settings later via governance: proposal friction can be properly embraced as a feature rather than a defect, making governance and policy complementary rather than competing.

The design of policies as deterministic, rule-bound plugins that are governed in scope, enables their execution to be permissionless to trigger by anyone at any time.

Imagine a policy plugin that has one simple job: withdraw a fixed monthly budget and split it 50/50 between two team multisigs. The logic is defined upfront, but the recipients and split ratios live in settings and can be changed later via governance.

Imagine automated buybacks. Automated burns. Any deterministic action is conducive to automating with policy

Why now

Onchain protocols and DeFi rails have matured. Governance-heavy DAOs, in this new environment, are no longer the solution to many of the problems they’ve previously been used for.

Governance still matters, particularly when it comes to ownership rights, but it matters within a narrowly-scoped discretion space, and most of the rest should be automated.

Regulators are reinforcing this split. They’re beginning to treat discretionary control and codified, rule-based systems differently.  This is particularly relevant when a small group manually steering treasury flows is a managerial “third party” while, in contrast, a system executing explicit financial policies is an auditable “infrastructure”.

In a climate increasingly sensitive to discretionary authority of capital flow, codification is cleaner and safer.

This is why we are starting to automate capital flows into policy plugins that implement an organization’s financial policy. Most onchain activity is already financial anyway, and these behaviors are becoming increasingly low variance and repeatable. That makes them ideal candidates for automation.

Tokens with no provable claim to the value being created by their corresponding project are unsurprisingly well down their path toward $0. Policy-driven capital flows make that idea programmatic by determining who gets paid, from where, and under what rule. Once flows are automated, the remaining discretionary governance surface, decentralized or via a trusted intermediary becomes sharper, focusing on strategy, structure, and policy update.

Part 2 of this article will zoom in on policy-based capital flow, introducing a small set of primitives and showing how they let organizations encode financial policy, plug into DeFi, route capital programmatically, and distribute value to stakeholders.