AshaCoreSovereign web platform · built by a team of AI agents
DE
PlatformProductsThe CompanyPilotUse CasesContactDeutsch

The company of AI agents

Software built by a company that doesn't exist — yet works.

AshaCore doesn't build itself — but almost. Behind the platform stands a virtual software company of AI agents with clearly separated roles, a supervisor and a daily cadence.

The agent company's work loop — a read-only supervisor observes the hand-offsSix roles form a clockwise loop: 1 standup, 2 project manager plans, 3 orchestrator distributes, 4 worker builds, 5 inspector reviews, 6 integrator merges — then back to the standup. In the centre the supervisor observes read-only and routes the next role.Supervisorread-only · observes & routes1Standupdaily cadence2Project Managerplans3Orchestratordistributes4Workerbuilds (isolated)5Inspectorreviews6Integratormerges (green gate)

The roles in detail

Architect

Keeps the platform and its decisions consistent.

  • Designs the architecture and documents decisions
  • Delivers criteria and dependencies, not deadlines

Doesn't plan the backlog or create others' tasks.

Project Manager

The only planner — slices work into waves.

  • Turns findings into tasks and order
  • Keeps the board clean and prioritises

Doesn't write production code itself.

Orchestrator

Distributes independent work in parallel, collision-free.

  • Bundles tasks into disjoint waves
  • Issues an isolated working copy per task

Doesn't merge anything into production.

Integrator

Merges finished, green states.

  • Checks the quality gate and the order
  • Takes over reviewed states under control

Moves nothing to production without explicit human approval.

Inspector

Reads the code and finds what isn't captured yet.

  • Reviews states independently
  • Reports gaps as findings to the planner

Changes no code — read and report only.

Supervisor

Watches the hand-offs and derives the next role.

  • Tracks open hand-offs
  • Prepares the next step

Only routes (read-only) — does no work itself.

Two teams, a second opinion

Two agent teams work together: one builds, the other reviews independently against it. Four-eyes principle, only with machines — contentious points are escalated for a decision, not silently passed over.

How the company works

01

Files, not hallway talk

Every hand-off is a versioned file, not a lost chat. Every step is traceable and resumable from any machine.

02

A daily cadence

A scheduler triggers a standup tick every morning: it checks the state, gathers open hand-offs and prepares the next steps — before the day begins.

03

Guardrails first

The supervisor only routes (read-only). Everything outward-facing — deploy, production, DNS — stays a deliberate human decision.

Guardrails

What the company decides itself — and what deliberately stays with the human.

AreaAgents mayHuman decides
Plan & buildSlice tasks, build code, write tests—
Hand-offsVersioned file hand-offs, routing (read-only)—
Production / deployPrepare finished, green statesApproval & release to production
Domains & DNSPropose configuration as dataOutward-facing DNS changes
Accounts & accessMaintain the role modelGrant new accounts, tokens, permissions

A day at the company

  1. Morning

    Standup cadence

    A scheduler triggers the standup: open hand-offs are gathered, the state is checked.

  2. Then

    Plan

    The project manager slices the next wave from findings and priorities.

  3. Late morning

    Distribute

    The orchestrator distributes independent tasks — one isolated working copy each.

  4. Through the day

    Build

    Workers build step by step, with tests and a green quality gate before every commit.

  5. In parallel

    Review

    A second team reviews independently against it — four-eyes principle with machines.

  6. To close

    Integrate

    The integrator takes over reviewed, green states — production stays human-approved.

  7. Ongoing

    Observe

    The supervisor tracks the hand-offs and prepares the next step.