Hi everyone, I’ve been building NEUS using Cursor over the last 2 years, and now are fully orchestrating agentic workflows across fragmented tools, context, identity, and authority.
Your AI agent just rewrote 14 files. You reviewed the diff, tests passed, you merged.
Now someone asks:
- what exactly did the agent decide on its own?
- Did it stay in scope?
- Who authorized the changes?
- Can you prove it?
You can’t. Not really. You have git log and a “vibe” it looked fine.
That’s the gap. We hand agents file access, terminal access, push access, and then trust the output on faith. No identity tied to the agent. No permission boundary that says “this agent can touch these files, not those.” No receipt proving what happened, when, and under whose authority.
NEUS gives every AI coding agent a verifiable identity, attaches signed receipts to each action, and lets permissions travel with the agent across any IDE. Cursor, VS Code, JetBrains. Same identity, same rules, same audit trail.
If anyone else has hit this wall. How are you handling agent accountability today?
What NEUS Is
Three things, specifically.
1. A trust protocol. Every agent action generates a receipt. A file edit, a tool call, a delegation to another agent. Each one produces a signed record that includes who authorized it, what was done, when, and under what rules. Receipts are verifiable offchain, with optional onchain anchoring.
2. A cross-IDE identity layer. Your identity is a universal address in DID format. You register agents under your profile. Those agents carry their identity, permissions, and trust history into any framework that connects to NEUS. Switch from Cursor to VS Code and your agent’s delegation chain, skill bindings, and rule set come with it.
3. An agentic orchestration system. You can run multiple agents with defined roles, schedule recurring jobs (revenue scans, outreach drafts, signal briefs), and chain agent outputs. Each step in the chain gets its own receipt. If agent B made a bad call, you can trace it back to agent A’s delegation and your original authorization.
How the Trust Loop Works
Five steps, every time an agent acts:
1. Authorize → You (the owner) grant an agent permission to act
2. Act → Agent performs the work (edit, research, tool call)
3. Prove → Agent generates a signed receipt for the action
4. Verify → Anyone (including you) can check the receipt independently
5. Recall → Receipt is stored durably for future audit
A receipt looks like this in practice:
{
"qHash": "0x4f0ebb9f2b500d96...",
"title": "Refactored auth middleware, 3 files changed",
"verifier": "Ownership",
"scope": "delegation",
"timestamp": "2026-07-25T14:32:00Z",
"agentWallet": "0x267a04f614f92469e6...",
"rules": [
"no-prod-deploys",
"require-human-review-for-secrets"
]
}
The qHash is a content hash of the receipt payload. You can verify it independently without a NEUS server. The receipt proves that this agent, acting under these rules, authorized by this controller, did this work at this time.
Delegation Model
You can delegate work to agents, and agents can delegate to other agents. Each link in the chain gets its own receipt.
You (owner)
└── delegates to → Agent A (research agent)
└── delegates to → Agent B (writing agent)
└── produces → Final output + receipt
If Agent B’s output has a problem, you trace the chain. Agent B’s receipt references Agent A’s delegation receipt, which references your original authorization. Every link is signed and verifiable.
A minimal agent config:
agent:
name: "code-review-agent"
type: "reviewer"
wallet: "0x267a04f614f92469e6..."
permissions:
- "read:files"
- "write:comments"
- "execute:lint"
rules:
- "block-deploy-without-approval"
- "flag-secrets-in-diff"
skills:
- "vercel-react-best-practices"
- "copy-editing"
That config is portable. It works in Cursor, VS Code, JetBrains, or any environment that reads NEUS agent profiles.
Agentic Orchestration
NEUS supports multi-agent workflows with:
- Job scheduling: recurring tasks (e.g., daily signal briefs at 8 AM CT, outreach drafts at 8:30 AM CT)
- Safety nets: each job gets a server-side receipt even if the agent fails mid-run, so you always know what was attempted
- Skill binding: agents can be bound to specific skill receipts (copywriting, marketing psychology, code review) that inject domain expertise into their context
- Sub-agent routing: a parent agent can delegate specific deliverables to specialized sub-agents
Example workflow for a code review pipeline:
1. You schedule a daily review job (recurring, 9 AM)
2. Review agent scans the latest commits
3. Review agent delegates to a lint agent for style checks
4. Lint agent delegates to a security agent for secret scanning
5. Each step generates a receipt
6. You get a summary with links to every receipt in the chain
If the security agent flags something, you can see exactly which commit, which agent, which rule triggered it, and trace back to your original job authorization.
Cross-IDE Integration
This is the part that matters for Cursor users specifically.
Today, if you use Cursor for feature work and VS Code for debugging and JetBrains for refactoring, each tool has its own agent config, its own permissions, its own chat history. Nothing carries over.
With NEUS:
- Identity: your address is your identity across all three IDEs
- Permissions: defined once in your profile, enforced everywhere
- Receipts: generated by any agent, stored in one trust graph, queryable from any IDE
- Skills: bound to your profile, available to any agent you authorize
- Rules: operating constraints (like “no prod deploys without approval”) follow you across tools
You configure once. Every IDE that connects to NEUS loads the same trust layer.
Practical Setup
Five steps to get started.
1. Register a profile. Connect any account. This becomes your trust graph controller. Your identity is portable across every tool and framework you connect downstream.
2. Define your agent. Set name, type, permissions, and rules. This works for IDE-embedded agents and standalone agent frameworks alike. The config is the same either way.
3. Bind skills. Attach skill receipts (code review, best practices, security scanning) to your agent’s profile. Skills inject domain guidance into agent context regardless of which framework runs the agent.
4. Connect your agent. This is where BYOA comes in. NEUS does not care which framework your agent runs on.
- IDE-embedded agents: Cursor, VS Code, JetBrains. The agent profile loads from NEUS, not from local config.
- Standalone frameworks: OpenClaw, Hermes, or any framework that reads NEUS agent profiles. Point your framework at your NEUS profile URL and the identity, permissions, rules, and skill bindings load the same way they do for an IDE agent.
- Bring your own agent: running a custom agent in CI, a script, or a headless pipeline? Register it under your NEUS profile with the same config format. It gets the same receipts, the same permission scoping, the same audit trail.
No framework-specific adapters. No per-tool reconfiguration. The trust layer is the same whether your agent lives inside an IDE or runs headless in a pipeline.
5. Start working. Every agent action generates a receipt. Check your trust graph at any time to see the full audit trail. Receipts are queryable from any connected tool, so you can audit an OpenClaw run from Cursor, or a JetBrains agent’s history from a Hermes script.
What’s Verifiable
| Receipt type | What it proves |
|---|---|
| Ownership | You own this agent, skill, or profile |
| Delegation | Agent A was authorized by you to delegate to Agent B |
| Memory | A specific fact or note was recorded at a specific time |
| Rules | An operating constraint was in effect when an action was taken |
| Instruction | An agent was given specific how-to-act guidance |
| Research | Findings were sourced and recorded with citations |
| Permission | An agent had explicit permission to perform a specific action |
Every receipt has a qHash you can verify independently. Receipts are offchain by default. No gas costs, no blockchain dependency. On-chain anchoring is available if you need it, but it is opt-in.
Use Cases for Cursor Users
1. Audit trail for agent edits. Cursor’s agent rewrites 14 files. Each edit generates a NEUS receipt. Two weeks later, you search your trust graph for “auth middleware” and see exactly what changed, when, under what rules, and which agent did it.
2. Multi-agent review pipelines. Your Cursor agent writes code. A NEUS review agent checks it. A security agent scans for secrets. Each step is receipt-backed. If something slips through, you trace the chain.
3. Permission-gated deploys. Set a rule: block-deploy-without-approval. No agent in any IDE can trigger a deploy without your explicit authorization. The rule lives in your NEUS profile, not in a CI/CD config file.
4. Cross-IDE consistency. You start a task in Cursor, switch to VS Code for debugging, finish in JetBrains. Same identity, same permissions, same trust graph. Your agent’s history follows you.
Links and Next Steps
- Website: https://neus.network
- Github: GitHub - neus/network: The trust layer for people and AI. Portable identity, context, and authorization that travels. · GitHub
If you find this useful, I’d love to collaborate and work towards improving agentic orchestration and cross system trust.