Every concept is a dark forest.
Give your agents a flashlight.
Latent expands seed concepts into rich conceptual landscapes — across domains, into depth, or bridging two seemingly unrelated ideas. Orient through the latent space with angular precision. Find its boundaries with Horizon. All outputs are injectable as context, traversable as graphs, or persisted to Logic.
3 tools
latent.expand · latent.orient · latent.horizon
3 expansion modes
depth · breadth · bridge
Graph or summary
inject context or traverse programmatically
Free forever · No credit card required
Three Tools. Complete Conceptual Navigation.
Start with latent.expand to illuminate the idea space. Navigate it angularly with latent.orient. Find its edges with latent.horizon.
Expand a Concept
The core Latent primitive. Takes a seed concept and expands it into a rich conceptual landscape using one of three modes: breadth (cross-domain connections), depth (hierarchical decomposition and edge cases), or bridge (shared abstractions between two concepts). Output can be a dense summary paragraph for context injection or a structured graph of nodes and edges for programmatic traversal.
Capabilities
- depth mode: drill down into a concept's technical layers, failure modes, and historical evolution
- breadth mode: find isomorphic structures and orthogonal dimensions across domains
- bridge mode: discover shared abstractions and transformation paths between two concepts
- summary format: dense paragraph for direct context injection into agent system prompts
- graph format: structured nodes/edges with relation types, weights, and domain labels
- levels 1–3: tune expansion intensity vs. credit cost
- domain_hint: bias the expansion toward a target field
Designed to chain
How Agents Use Latent
From research priming to systematic conceptual cartography — Latent gives agents a structured way to explore ideas that keyword search can't touch.
Research Context Priming
Before starting a deep research task, an agent calls latent.expand in breadth mode to map the conceptual neighbourhood around the research question. The summary output is injected directly into the system prompt, giving the agent a richer starting map before it begins querying external sources.
Related Solutions
Cross-Domain Analogy Discovery
An agent working on a distributed systems architecture problem uses latent.expand in bridge mode to find shared abstractions between 'consensus algorithms' and 'immune system coordination'. The unexpected structural parallels surface novel design patterns that wouldn't appear in a keyword search.
Related Solutions
Systematic Conceptual Exploration
A research agent systematically navigates the latent space of a technical concept by calling latent.orient with different axes — first 'negation' to understand what the concept is not, then 'scale' to find how it behaves differently at different magnitudes. Explored facts persist to Logic so the agent knows which axes remain.
Related Solutions
Concept Boundary Detection for Prompts
Before writing a complex prompt that relies on a fuzzy concept like 'autonomy' or 'trust', an agent uses latent.orient then latent.horizon to find where the concept stops being coherent. This prevents prompts that inadvertently straddle a conceptual boundary and produce inconsistent model behaviour.
Related Solutions
Technical Depth Decomposition
Given a concept like 'cache invalidation', an agent uses latent.expand in depth mode at level 3 to produce a hierarchical decomposition covering domain-specific formalizations, edge cases, failure modes, and historical evolution — producing a knowledge scaffold that guides downstream API calls and reasoning steps.
Related Solutions
Persistent Latent-Space Knowledge Graph
An agent conducting ongoing research persists all latent.orient and latent.horizon results to a named Logic namespace. Over multiple sessions, it builds a queryable knowledge graph of explored conceptual territory — using logic.query with Prolog graph predicates to ask 'which axes haven't been explored yet for this concept?'
Related Solutions
Latent Connects to Every Reasoning Layer
Conceptual expansion is more powerful when it flows into memory, analysis, visualization, and planning — Latent chains cleanly with every DataGrout tool that consumes context.
Persistent Conceptual Knowledge Graph
Orient and Horizon both support persist=true, writing typed relation facts directly to a Logic cell namespace. Over time, agents build a queryable knowledge graph of explored conceptual territory — and can ask open-world questions like 'which axes haven't been explored yet for this seed?' via logic.query.
✦ Accumulate a reusable concept map across sessions without re-running expensive expansions
Expand Then Analyze or Visualize
Use latent.expand in graph format to produce a structured node/edge graph of related concepts. Pass the cache_ref to prism.refract for semantic analysis, or to prism.chart for a visual concept map. No data re-transmission — chain entirely via cache_refs.
✦ Turn a conceptual expansion into a visual map in two tool calls
Semantic Tool Discovery from Concept Expansion
After expanding a concept in breadth mode, use the related concepts and domain labels returned by latent.expand as inputs to discovery.discover. This lets agents find relevant tools semantically anchored to the conceptual neighbourhood rather than guessing tool names.
✦ Let concept exploration guide tool selection — not the other way around
Concept-Guided Multi-Step Plans
Use latent.expand as the first step in a flow.into plan to build a rich conceptual scaffold, then have subsequent steps reference specific concepts from the expansion as inputs for downstream queries, analysis tasks, or code generation — producing plans grounded in the full semantic neighbourhood.
✦ Plans that start from understanding, not just keywords
Integrate Latent in Minutes
All three Latent tools are standard MCP calls — available via any MCP client or the Conduit SDK.
from datagrout.conduit import Client
async with Client(
"https://gateway.datagrout.ai/servers/{uuid}/mcp",
auth={"bearer": "your-access-token"}
) as client:
result = await client.perform("data-grout@1/latent.expand@1", {
"seed": "cache invalidation",
"mode": "breadth",
"format": "summary",
"levels": 2
})
# result["expansion"] — dense paragraph, ready for context injection
# result["concepts"] — list of related concept labels
# result["dimensions_explored"] — how many directions were explored
# result["_meta"]["cache_ref"] — chain to prism, frame, data, etc.
# Inject directly into next LLM call's system prompt
enriched_context = result["expansion"]
print("Concepts found:", result["concepts"])Also available in TypeScript, Rust, Elixir, and Ruby. View Conduit SDK →
Frequently Asked Questions
What developers ask before wiring Latent into agent context pipelines.
More questions? Read the full Latent documentation.
The idea space is enormous.
Now your agents can navigate it.
Latent gives every agent a structured flashlight for the dark forest of concepts — expanding, orienting, and bounding ideas that keyword search can't reach.
Free forever · No credit card required