Summary of The Forty2 Project

We're a community welcoming everyone, aimed to cooperate (work together to benefit the members) in the most optimal, 21st century way: using computers for increasing the decision-making performance (quality and speed) by distributing the decision-computation tasks in between members and computers, with the goal of full automation, finally getting away from the (ancient) hierarchical managements where human minds are computing them. We're starting small, incrementally and gradually optimising our abilities, aiming to Switch Earth On.

In other words

Cooperating for the benefit of the members, fairly, increasingly optimally, managing ourselves by:

  • At first distributing the decision-computation tasks [e.g., finding solution ideas/action-candidates, evaluating their benefits/drawbacks, comparing them to others, etc.] among members to improve decision quality and speed, using strict processes with which we can convert the most important tasks into formal proofs.
  • Increasingly using computers to compute decisions, utilizing the — by now gigantic — advantage of computers in computational tasks over human minds.

Our minds are amazing, but they are slow and make mistakes, especially in complex problems. Computers can help solve these problems better, so we use computers for computation, even on management levels... duhh...

In - yet again - other words

With this project we're aiming to finally solve the problem of managing a group (aimed to satisfy its members the most, e.g., a country or a self-help group) at the very least with the efficiency that the group is getting closer to its goals over time (i.e., it does not deteriorate). Our real goals are — by moving the computation of decisions from the minds to the computers — to build a system that improves itself exponentially, which would finally develop the tools with which we can provide the members practically limitless ways to fulfill their needs and desires [except if the desire is to force other members to do things they don't want].

Toward Optimal Cooperation: Logic-Driven Management for Complex Communities

Some theories first:

  • Cooperation for the benefit of the members: Cooperation (NOT corporation!) is about working together to reach a common goal. Here the goal is to get the most value for the members (~more profit), more than if we worked alone, distributing the work among the members so that we work most efficiently.
    Examples:
    • A "good" family or friend group doing things together to make members happy/satisfied.
    • A corporation: while a cooperation, the goal is not to satisfy the members (even if they say "we're family") but the owners.
  • It's now in our interest to cooperate this way:In this current world, the things you need are mostly and increasingly made by work from almost unlimited resources [i.e., the share of the cost of natural resources is decreasing in the cost of the final product, e.g., we can grow crops without soil, spend large sums on things requiring very little or no physical material like your smartphone or software, an online service; if we had to, we could mine asteroids]. So it is in our interest to be a member of a group that does this work as efficiently as possible and then shares the results fairly, optimally cooperating with the highest number of people — as opposed to the world in the past, where you took things from nature using finite resources, therefore it was in your interest to fight (and rob, kill, enslave) other groups so that it was you who eats the deer and not them, it was you who takes the land and not them.
  • Optimal cooperation:
    • Definition: The members use their resources (work + material) in a way that serves the interest of the group the most.
    • In other words, they manage the resources (themselves and what the group has) optimally; their management makes (closest to) optimal decisions according to the total information the group possesses.
    • Examples:
      • It's an optimal decision to bet $1 in a coin toss game paying $3 to the winner if we have information that it's a fair game, even if the coin landed on the wrong side and we lost.
      • From the perspective of humanity (trying to achieve the most benefits per spent effort),it's not an optimal decision to spend money on developing multiple, similar software products (e.g., those myriads of chat applications) and compete with others for users.
        It's closer to optimal to unite development resources into one group, developing different software for different purposes and sharing the software and profit.
    • The larger the group, the harder it is to manage it optimally. While some problems—like digging a huge hole with shovels—have management effort proportional linearly to the number of group members, complex cases with dependencies, multiple options to solve problems, different skills, efficiencies, etc., have management complexity best approximated by exponential or even factorial curves.
      Example:
      • Suppose you are five (logical-minded) friends on a trip trying to solve the breakfast problem. Everyone chips in ideas: who goes to which shop, who cooks, when does each person do what; you discuss, think through, and agree on a solution everyone finds best. You could have an optimal sharing of work: combining all ideas, measuring how good each is, and choosing the best, everyone verifying computations in their head so the likelihood of errors is low.
      • Now imagine the same with just 50 people: even collecting and storing ideas in your head is nearly impossible — but this is still linear complexity, you are just not good at memorizing long lists of ideas (computers are). Now the combination of ideas becomes vastly more complex: you have different needs, skills, time availability, and ideas to solve sub-problems (cooking, shopping, different diets, etc.). You'd need to combine each idea with each other idea to find the best combinations. This is combinatorics, measured by factorials: for 100 ideas, there are 100! = 9.332622e+157 permutations to check.
      • While heuristics and tricks can reduce complexity, even if you check just 0.0000001% of combinations, that's still a huge number. So, decisions become compromises expected to be "not that bad for most people."
  • So far, we've handled these with hierarchical management: each level simplifies problems from the previous layer to approximate optimal decisions—"very broad strokes." Even if managers or politicians were highly skilled and honest, this approach yields very far from optimal results, as we can all experience.

Important to notice:

We can represent a community as a system with abilities to interact with the world and with an internal decision-making structure to compute how to interact (what to do). The system's performance with given resources in a given environment depends solely on one factor: the quality and speed of its management — how quickly it can solve complex problems with precision.

The current world uses ancient "people decide in a hierarchy" systems, not utilizing computers to compute these super-complex problems. We're slow to change, especially if those in power don't understand or don't want this.

In practice, no current management method (democracy, hierarchical systems like kingdoms, dictatorships, company structures) can prove that their decisions are moving the group closer to its goals — mostly because logic doesn't hold power; people do.

Therefore:

  • Building a method of managing large groups where logic holds power — so decisions are not whims of bosses but what is correct — is in our best interest.
  • If that method is also self-improving and hugely outperforms current management in quality and speed, it would be awesome.
  • That's what we're doing: as a cooperation, we're first focusing on gradually moving computational tasks of management into a system consisting of people and software, formalizing the decision scenario, breaking it into parts, and distributing it among "computing units" (people + software) to increase decision quality and speed exponentially, then shifting focus to providing "happiness" to group members by efficiently producing what we need and welcoming more people.

Why we are doing this

On a small scale:

To benefit from a community that turns our invested effort into "profit" far more efficiently than other ways (e.g., being an employee or investing in a hierarchically managed company).

On a large scale:

After our systems can handle thousands then millions of people, to provide a solution for cooperating on humanity's level — to finally form Earth's decision-making body, stop the crazy self-destructive path, and Switch Earth On.

In general:

While constantly experiencing the consequences of trivially sub-optimal decisions by people in power, this question bothers us relentlessly: Why are we still using systems made for kingdoms and empires? They were the only option before the internet and modern computing, but now better options exist — we just don't use them, despite how easy it would be.

How It started

Former computer programmer geeks/enthusiasts working in software development and management, experienced in automating management decisions (managing ALM tools development), realized:

  • It would be relatively easy (high benefit/cost ratio) and essential to fully automate management decision processes, creating "The Tool" to gradually do so.
  • None of the currently available software can serve as The Tool; many are close but have problems (codebase quality, feature set, ownership) that would take longer and cost more to fix than writing one from scratch.
  • Making an MVP (minimum viable product) version of The Tool suitable for people not afraid of character-based UIs (like programmers) is an "easy" task, taking a few thousand senior developer hours only.
  • Compiling and fine-tuning processes (and implementing them into The Tool) to manage ourselves should take a few months, allowing us to manage a few dozen people without hierarchical approaches — a "managementless management" where logic holds power, not people.

The preferred approach is to form a forever-improving and expanding community that gradually encodes its decision-making practices into The Tool, rather than through companies. We've found this is complicated and hard to pitch—especially to managers, who are often not eager to be replaced by software, etc.

We've spent years researching, developing, and testing theories, PoCs, marketing and funding strategies; developed and tried initial processes to ensure high decision quality with basic tools; worked out plans and started executing them. It looked promising, so we started public outreach with a Reddit post seeking programming buddies — to which, after filtering, we gained the first outside community members.

For now, we are a small group

We're mostly preparing processes and materials for the next expansion iteration: a proper website (basically the one you're reading), requirements, tasks, and processes to guide new joiners so they can work productively with little help.

In general, we're forming a system always doing the task with the highest utility/cost ratio:

  • "Utility" is computed from big goals we want to reach. Current subgoals include:
    • Improving processes so we can utilize more "computing units" — currently humans.
    • Creating the software platform where we can formalize our processes: the first version of The Tool — like a "Jira++++" with more freedom and less UI.
  • Computing units are mostly humans; we're gradually automating our work.
  • Because humans make many errors, we're trying to ensure correct computation in decisions (=decisions should be logical), keeping theoretical basics — decisions must follow from information we have, logic rules; formalizing the decision scenario and computing it if needed. Everyone is a worker, shareholder, and decision-maker if needed; decisions and circumstances are shared, questioned, and analyzed by the team.

Current expansion

We're looking to expand to around 10–42 people to:

  • Finish the first version of The Tool.
  • Fine-tune processes so founding members do not need to watch every step, making the system self-improving with little supervision.

Soon

As our systems progress, we will gradually admit more people, increasing effort to improve efficiencies or produce "profit." The original team will consider the system "done" once it can make optimal decisions without their contribution — expected at around 1,000 people scale.