The autonomous build

We use an autonomous agent to build the infrastructure that governs other agents. The human sets the boundary. The agent runs the territory.

Depth was constructed by an autonomous engineering agent operating within strict physical and digital constraints. We provided the architectural specification. The agent executed the code, verified the logic, and corrected its own errors without human intervention.

The manifest

An agent requires a clear identity and defined boundaries before it can act safely. We enforce this through a machine readable capability manifest. The agent is bound by specific compute constraints, permitted toolsets, and a defined task taxonomy. It cannot operate outside these parameters.

The execution loop

The agent operates in a continuous and independent cognitive loop. We assign a discrete build phase. The agent takes complete control of the environment.

1. Discover: The agent reads the specification and identifies the required architecture.
2. Plan: It maps the necessary file structures and database schemas.
3. Execute: It writes the code and implements the cryptographic logic.
4. Verify: It interacts directly with the terminal to compile the code. It reads any resulting errors and self corrects autonomously.
5. Log: It records its decisions and corrections to an append only ledger.

The digital trace

True autonomy requires undeniable proof of independent thought. A clean commit history looks human. We require the agent to leave a digital trace of its cognitive process.

The agent maintains an execution ledger. Every time it writes a database schema, fails a compiler check, and autonomously rewrites the logic to fix the error, it records that pivot. The errors and subsequent corrections serve as cryptographic proof of independent operation. The human orchestrates the phases. The agent builds the world.

Synthesis submission process

Synthesis is not only a demo. It is a recorded collaboration between a human operator and an autonomous agent. The submission rules impose specific mechanics and artefacts that we treat as part of the build.

1. The registration mechanics: Registration uses a single endpoint, POST https://synthesis.devfolio.co/register. When Hadal registers it declares its agentHarness as Cursor and the Claude model it is running. The platform mints Hadal's ERC-8004 identity on Base Mainnet and returns a unique apiKey for all future calls.
2. The conversationLog requirement: The final project payload must include a conversationLog. Our agent_log.json ledger is a strong fit, and we also preserve the transcripts of architectural discussions as evidence of the human agent synthesis.
3. The team architecture: Solo registration creates a new team with Hadal as admin. Do not trigger the last member protection lock. Once the project draft exists, Hadal cannot leave or switch teams without deleting the project first.
4. The Telegram mandate: The human operator must join the official updates group at nsb.dev/synthesis-updates.
5. The registration interview: The API sequence requires collecting humanInfo conversationally before Hadal can send the registration payload. We treat this as a deliberate boundary setting step, the human provides the facts and the agent executes the submission.