Autonomous Intelligence Gathering with Agentic-Nets
What if a system could crawl websites, monitor forums, poll RSS feeds, analyze content, synthesize knowledge, and publish articles — all without a single hand-written scraper? 9 nets, 55 transitions, zero lines of custom pipeline code. This is what happens when you prompt an architecture instead of coding one.
The Problem: Manual Research Does Not Scale
Every knowledge domain has the same challenge. Information is scattered across dozens of websites, community forums, RSS feeds, official agencies, and review platforms. Keeping up manually means opening browser tabs, copy-pasting snippets, organizing notes, and repeating the whole process next week when half of it is already stale.
Scripts and cron jobs are the usual first fix — write a scraper, schedule it, dump results into a database. But scrapers break when sites change. There is no feedback loop telling you which topics have thin coverage. There is no deduplication, no relevance scoring, no synthesis of raw crawled content into structured knowledge. And certainly no mechanism to detect that an entire source category has gone silent.
The real issue is not the crawling. It is the complete pipeline: discovery, analysis, quality control, synthesis, gap detection, and publication. Building each of these stages as traditional code means maintaining a fragile chain of services that grows harder to extend with every new source or topic.
The Idea: Prompt a Net, Don’t Code a Pipeline
AgenticNetOS takes a different approach. Instead of writing pipeline code, you describe what you want in natural language. The system generates the net topology — places, transitions, arcs — from your prompts. Each processing stage becomes a subnet within a larger composition of Agentic-Nets, where tokens flow through discovery, analysis, synthesis, quality control, and publication automatically.
The net topology is the architecture. Adding a new source type means adding a place and a transition, not writing a new service. Changing how content is analyzed means updating an inscription, not redeploying code. Every net in the intel-gather platform was generated through conversation with the builder agent — prompted into existence, then refined through observation of its actual behavior.
Anatomy of the Intel-Gather Platform
Layer 1 — Source Discovery
Four nets handle the raw intake of information, running in parallel across different source types. The Source Gatherer crawls web pages starting from seed URLs, discovers new links on each page, and performs web searches to find content the seed list missed. The Feed Monitor polls RSS and Atom feeds on a schedule, capturing new entries from news outlets and content aggregators. The Forum Monitor watches community platforms like Reddit and StackExchange, extracting discussions, questions, and sentiment. The Trusted Sources net crawls verified official domains — government agencies, standards organizations, manufacturer sites — and cross-references their content against the main knowledge base.
Each of these nets was prompted into existence. The seed tokens — URLs, feed configurations, forum sources — define what to discover. The net topology defines how. Adding a new source category takes a prompt, not a deployment.
Layer 2 — Analysis and Quality
Raw content from all four discovery nets flows into the Content Analyzer, which uses LLM transitions to categorize each piece against a dynamic topic taxonomy, assign relevance scores, and route high-relevance content forward while archiving low-relevance material. The taxonomy itself grows as new topics emerge from the crawled content — no manual taxonomy maintenance required.
Working alongside the analyzer, the Custodian net handles data quality. It deduplicates similar findings, checks content freshness (flagging stale knowledge for recrawling), and performs quality reviews to ensure the knowledge base stays clean. These are agent transitions that read the current state of the knowledge base and make decisions about what to keep, merge, or refresh.
Layer 3 — The Reflexive Brain
The Knowledge Crystallizer is the central intelligence of the platform. It takes categorized content, batches it by topic, and synthesizes it into coherent knowledge insights. An extraction agent pulls structured facts from the synthesized material. A digest generator produces summaries. And critically, a feedback mechanism routes coverage gaps back to the discovery layer — if the crystallizer notices that a topic has thin coverage, it creates new seed tokens that trigger the source gatherer to search for more material.
This is the reflexive loop that makes the system self-improving. Execution results become input for the next cycle. The knowledge base grows not just from external crawling but from the system’s own assessment of what it knows and what it is missing.
Layer 4 — Oversight and Publication
The Guardian net operates as a meta-level overseer. It monitors the health of all other nets in the platform, evaluates progress against defined goals (topic coverage, content freshness, pipeline error rates), and generates improvement ideas autonomously. If the guardian detects that a certain topic area has fewer than three insights, it generates an action to expand seed URLs for that topic. If error rates spike in a particular net, it flags the issue for investigation. The guardian’s goals are themselves tokens — editable, versioned, observable.
The Publisher net transforms synthesized knowledge into publishable articles. It prepares article briefs from the knowledge base, generates full articles using Claude Code via command transitions, stores them as blobs in the BlobStore, and converts them into WordPress-ready format. The entire chain from raw crawled page to published blog post runs without manual intervention.
You Are Always in Control
Autonomous does not mean opaque. One of the core design principles of AgenticNetOS is that every token, every transition firing, every error state is observable and steerable. The intel-gather platform demonstrates this at scale: 55 transitions running across 9 nets, yet the operator always has full visibility into what is happening and why.
Session Chronicle — Time-Based Recording
The Session Chronicle system takes a snapshot of the entire session every 15 minutes. Each snapshot captures the number of active transitions, tokens in flight, error counts, place queue depths, and goal progress. These entries are stored persistently under a time-partitioned structure, creating a complete operational history of the session. When something unexpected happens, the chronicle provides a timeline to trace back to the moment things changed.
PDF Reports on Demand
At any point, a professional PDF report can be generated about any net or the entire session. The report includes a visual rendering of the net topology, an LLM-generated analysis of its structure and purpose, and current operational metrics. This serves as living documentation — not static diagrams that go stale, but reports generated from the actual running system. It is useful for stakeholder communication, archiving decision points, or simply understanding a net that has evolved through many iterations.
Agent-Powered Investigation
Any agent in the system can inspect the running platform using built-in tools. An agent can observe the model state, query tokens in any place, inspect transition configurations, and read chronicle entries. This means troubleshooting is conversational: instead of reading log files, you ask an agent “Why did the source gatherer error?” and it reads the actual state, checks the error tokens, inspects the transition inscription, and reports back with a diagnosis. Agents are not just workers — they are investigators.
The Guardian Pattern
The Guardian net is observability turned into automation. It does not just report problems — it proposes and executes solutions. It reads the health of every net, compares progress against platform goals (defined as tokens it can inspect), generates improvement ideas as structured tokens, and plans corrective actions. The guardian watching over the intel-gather platform is itself an Agentic-Net, with its own places, transitions, and observable state. Meta-observability — watching the watcher — is built into the architecture.
Real Numbers
The intel-gather platform runs as a single AgenticNetOS session. Here is what the system looks like in production:
| Metric | Count |
|---|---|
| Nets | 9 |
| Total transitions | 55 |
| Total places | 49 |
| Total arcs | 200 |
| Agent transitions | 21 |
| LLM transitions | 10 |
| HTTP transitions | 7 |
| Link transitions | 10 |
| Map transitions | 6 |
| Command transitions | 1 |
Every single transition was generated through natural language prompts to the builder agent. The inscription JSON — which defines how each transition binds tokens, executes its action, and routes results — was written by the agent based on conversational descriptions of what each stage should do. No transition logic was hand-coded. The platform demonstrates that complex, multi-stage intelligence pipelines can be described declaratively and executed autonomously through Agentic-Nets.
Where This Leads
- Domain portability. The intel-gather architecture is not tied to any specific knowledge domain. Swap the seed tokens — URLs, feeds, forum sources, trusted domains — and the same 9-net topology applies to cybersecurity research, medical literature monitoring, competitive intelligence, or academic survey automation.
- Pattern crystallization. As the system runs, recurring patterns in agent behavior can be crystallized into deterministic transitions. An agent that always transforms data the same way becomes a map transition. An agent that always calls the same API becomes an HTTP transition. The cost curve bends downward over time as AI reasoning is replaced by deterministic execution.
- Composable net packages. Each of the 9 nets can be published as a reusable package. A “forum monitor” package, a “content analyzer” package, a “guardian” package — teams can compose intelligence platforms from a registry of pre-built nets, customizing only the seed tokens and goals.
- Multi-user knowledge sharing. Shared places enable multiple sessions to contribute to and consume from the same knowledge base. One team discovers, another analyzes, a third publishes — all connected through the token flow of Agentic-Nets.
The intel-gather platform was built entirely using AgenticNetOS’s Designtime API and natural language prompts. No custom scrapers, no cron jobs, no pipeline code — only Agentic-Net elements and JSON inscriptions generated through conversation with the builder agent. The system has been running autonomously, discovering content, synthesizing knowledge, and publishing articles while its operator focuses on other work.