Orchestra now supports decentralized tagging, registry search, and composite queries — with no offchain indexers required.

The most powerful systems are not the ones that do the most things — they’re the ones that help you find what you need, when you need it, on your terms. With today’s update, Orchestra takes a major step toward that.

We’ve introduced native support for tagging, search, and registry discovery, enabling developers, applications, and agents to organize and query the chain in a structured, interoperable way — entirely onchain.

This isn’t a bolt-on metadata trick. It’s composable indexing logic, made available through a minimal, auditable system that works from first principles.

Orchestra is already a system built for programmable coordination. It treats identities, credentials, and assets as structured, permissioned objects — not loose blobs of metadata. Every change is timestamped, emitted as an event, and persisted for inspection.

But as more real-world systems move onchain — credentials, infrastructure registries, programmatic ownership, environmental assets — the challenge shifts from representation to discovery.

• What assets are tagged sustainable and issued by a verified registrar?

• Which registries are linked to collective groups in the finance: namespace?

• How do I find all identities with a certified_engineer credential issued by org:acme?

If you have to spin up a custom indexer every time, you’re not building a real-world chain. You’re building a proof of concept.

Orchestra now solves this.

Any onchain object — assets, identities, collectives, registries, programs — can now be tagged with structured, lowercase keywords.

{
  "object_type": "asset",
  "object_id": "asset:xyz123",
  "tags": ["sustainable", "depin", "solar"]
}

• Tags are stored under canonical keys like tag:sustainable:asset:xyz123

• Tagging is append-only and emits an object_tagged event

• Tags can be queried through CLI or RPC

CLI:

orchestra tag-object --id asset:xyz123 --tags sustainable depin solar

Tags are now a primary access path for discovery:

• getTagsFor(object_id) returns all tags for any object

• getObjectsByTag(tag) returns all object IDs tagged with that value

This enables fast, structured lookups — without needing external indexing.

Registries — Orchestra’s permissioned sets of assets or identities — now support:

• A namespace (e.g. finance, energy, credentials)

• A list of tags

Which means you can now:

orchestra get-registries-by-tag --tag green --namespace energy

Use cases:

• A compliance agent filtering registries in a specific domain

• A collective discovering all registries tagged with “open-data”

• A DAO tagging and searching its own asset pools

You can now submit basic multi-field queries like:

{
  "type": "asset",
  "tags": ["sustainable", "verified"],
  "linked_to": "identity:org:acme"
}

This is an early implementation — simple, linear scans — but it sets the stage for future onchain indexing engines and programmable search workflows.

Discoverability isn’t UX fluff. It’s a trust primitive.

When you’re operating in a permissionless network — with composable rules, real-world credentials, and cross-entity ownership — the ability to answer “what’s out there?” becomes foundational.

In Orchestra:

• Trust is modeled explicitly — via credentials, ACLs, registries, and link relationships

• Events are semantically structured — not raw logs

• Search is built-in, not bolted-on

This means agents, DAOs, and institutions can now:

• Build dashboards without maintaining offchain indexes

• Trigger workflows based on tag subscriptions

• Coordinate governance across tagged registries

• Discover and verify real-world assets by domain

No rollups. No subgraphs. No proprietary analytics infra. Just onchain coordination that works.

We’ll continue to expand on this in future phases:

• Namespaced tag roles (e.g. tag:curated:approved)

• Attestations on tags and registries

• Native discovery in the UI kit (useTagsForObject, useSearchByTag)

• Onchain search programs for agents

As always, the foundation comes first: structured data, verifiable behavior, and minimal, explainable rules.

Orchestra isn’t trying to build “the everything chain.”

We’re building a coordination layer for real systems — one where assets, identities, and relationships can be programmed, searched, and trusted by design.

This update makes that coordination discoverable.

You’ll be able to try it soon writing something as simple as:

orchestra tag-object --id asset:solar:789 --tags green verified
orchestra get-objects-by-tag --tag green

Orchestra is composable by default. Let’s keep composing.