Every claim, checked against
what is actually there.
Molthood runs an analysis, gathers evidence from independent sources, and reports what it found — including the checks it could not make. A check that did not run is never shown as a clean result.
- Every finding
- Carries its source
- Every gap
- Named, not hidden
- Every run
- Comparable
Each fact links to where it can be checked independently.
A failed lookup is reported as a gap, never as a pass.
Stored, so the next run can say what changed since.
Watch an execution as it happens
Each run moves through the same phases and reports what it found at every one. Nothing below is a demonstration — these are real executions their owners chose to publish, and the panel stays empty until somebody does.
Execution First
Most tools answer. Molthood finishes the work.
A language model that returns a plan still leaves the entire job on your desk. Molthood is built the other way around — the platform treats a request as work to be carried out, and the response is the completed result.
Requests, not prompts
You describe an outcome. Molthood decides which agents are required, in what order, and with which inputs.
Work that completes
Steps run to completion against the network. Nothing stops at a suggestion you still have to carry out yourself.
Evidence by default
Every stage emits an artifact as it finishes, so a finished run is something you can audit rather than trust.
Execution Pipeline
Every request follows the same five stages.
The path from request to report is fixed and inspectable. You always know which stage a run is in and what it produced along the way.
01
Input
A single natural-language request enters the platform.
02
Multiple AI Agents
The request is decomposed and routed to specialised agents.
03
Execution Engine
Approved steps run against Robinhood Chain in order.
04
Evidence Collection
Every step emits a verifiable artifact as it completes.
05
Final Report
Results are compiled into one auditable execution record.
Agent Roster
A specialist for each part of the job.
Agents are narrow on purpose. Each one owns a single domain, and the platform composes them into a plan so no single model has to be right about everything.
Market Agent
Reads token metadata, holders, and supply from the explorer, then prices it against Codex.
- Token metadata
- Holder distribution
- Live pricing
Risk Agent
Scores an on-chain subject from the evidence already collected, and names every signal behind the score.
- Concentration analysis
- Signal weighting
- Scored findings
Contract Agent
Checks whether a contract is verified, and reads its published source and interface.
- Verification state
- Source retrieval
- Interface reading
Project Agent
Reports the state of the chain itself — block height, throughput, and network activity.
- Chain statistics
- Network activity
- Wallet holdings
Site Agent
Reads a project's off-chain footprint: published policies, DNS and mail posture, domain registration, and archive history.
- Published policies
- DNS posture
- Registration and archive
Launch Agent
Takes a token or product from configuration to a verified on-chain deployment without manual scripting.
- Deploy pipeline
- Parameter validation
- Post-launch checks
Builder Agent
Scaffolds integrations and internal tooling against the Molthood execution API.
- Codegen
- Integration tests
- API bindings
Portfolio Agent
Screens every token a wallet holds against the same rules a full token analysis applies, worst position first.
- Holding screen
- Exposure ranking
- Shared scoring
Community Agent
Drafts, schedules, and evidences external communication tied to real execution events.
- Event triggers
- Draft generation
- Publish log
Network
Built exclusively for Robinhood Chain.
Molthood is not a general-purpose agent framework pointed at a chain. It is built for one network, and every decision in the platform follows from that.
- Single network
- No multi-chain abstraction layer to reason about or work around.
- Native primitives
- Agents are written against Robinhood Chain directly, not a lowest common denominator.
- One execution surface
- Every run settles on the same network, so evidence stays comparable.
Built so a mistake stays small
Each of these is a property of how the system is put together, not a policy someone has to remember to follow.
Executions are private by default
Every run is scoped to the key that made it. Nothing appears publicly unless its owner explicitly publishes it, and publishing is reversible.
Keys are stored as hashes
A key is shown once, on creation, and never again — there is no endpoint that can reveal one. A copy of the database yields no working credentials.
Spend is capped, not monitored
Each key carries a daily execution allowance enforced in the database, so a limit holds across restarts and concurrent requests rather than being checked after the fact.
Outbound requests are bounded
Private and loopback addresses are refused, every call carries a timeout, and a rejected request is never retried into a loop.
What to expect
What does Molthood actually produce?
A report. It carries the findings, the source behind each one, the checks that could not be made and why, and a timeline of what ran. Every figure links to somewhere it can be checked without trusting us.
What happens when a check fails?
It is reported as a gap, not as a pass. This is the single rule the whole system is built on: a lookup that could not run and a lookup that came back clean are different answers, and collapsing them is how a tool becomes dangerous.
Is anything I run visible to other people?
No. Executions are scoped to the key that made them, and the public feed shows only what an owner has explicitly published. A run records the subject it was about, which is precisely why it is private by default.
What if a data source is down?
The run continues without it and the report says which step did not happen. A missing source degrades coverage; it does not fail the execution or quietly shrink the report.
Can I see how a result was reached?
Yes. Every report includes the full execution timeline — the phases that ran, how long each took, and the ones that were skipped along with the reason.
Run your first execution
Create a key from the console — no account, no card. You get a daily allowance because each execution costs real compute, and the console shows exactly how much of it is left.