…But Is It Agentic?

🌱 It is growing in that direction. ACORN approaches agentic development through Intelligence in Depth (IID): the deliberate layering of AI capabilities so that each layer adds structure, context, continuity, or control.

In a Nutshell

IID layers prompting, templates, workflows, skills and context, memory, and agent harnesses. Each layer adds capability and control while staying local-first and file-oriented; MCP and ACP are optional extensions.

IID adapts the idea of defense in depth: an information security strategy that integrates people, technology, and operations across multiple layers.¹ Instead of expecting one prompt or one model to carry an entire workflow, IID distributes intelligence across reusable prompts, controlled workflows, skills and connected capabilities, memory, and an interoperable agent harness. The layers reinforce one another, but each remains useful on its own:

Arrows indicate composition and control flow, not increasing maturity or quality.

IID is an ordered architecture, not an ASPECT maturity scale. The sequence shows how each layer can structure, supply, or govern the layers before it. A system is not more mature for using an agent harness; it should use the shallowest sequence that reliably satisfies the task. IID is therefore not a synonym for maximum autonomy.

Intelligence in Depth

Guiding Principles

Two principles constrain every IID layer:

• Local-first. Data, models, validation, and orchestration remain on the user’s machine by default. The network and remote services are explicit choices, not prerequisites. Local-first preserves user ownership and offline operation without prohibiting synchronization or collaboration.²
• File over app. Durable instructions, context, state, and results live in files the user can control, retrieve, and read. Applications are replaceable tools that operate on those files rather than the only place the work can exist.³

Together they produce a third rule: protocols are adapters, not dependencies. MCP, ACP, and model APIs can connect IID to external capabilities without becoming the source of truth.

1. One-time prompting sends a direct instruction to a model through a library or API. It is appropriate for a single transformation or answer whose inputs and outputs are already well defined.

   Example: An application sends one research narrative to acorn-lib’s OpenAI-compatible chat-completion API with the instruction “Summarize this activity,” then returns the model’s response.

2. Prompt templates turn instructions into reusable, version-controlled .prompt files with defined inputs, configuration, and expected outputs. Templates make model behavior easier to share, test, and improve. Google’s Dotprompt specification documents this executable .prompt file pattern.⁴

   Example: ACORN renders its embedded summarize.prompt template with a source narrative, maximum word count, and output structure so different callers reuse the same instructions.

3. Workflow composition and iteration coordinates model calls, deterministic operations, and tools through explicit control flow. A workflow may sequence, select, repeat, delegate, or combine bounded tasks, but its path and safeguards remain defined by the application. Anthropic distinguishes these predefined workflows from agents that dynamically direct their own process and tool use.⁵ Repeating workflows require clear exit conditions, measurable progress, state passed between calls when needed, and limits on iterations, time, tokens, and cost.

   Example (planned): ACORN asks a model to address gaps in a research narrative, runs deterministic validation, and supplies any remaining findings to another bounded pass until no high-severity issue remains or the workflow reaches its iteration, token, or time limit.

4. Skills, context, and capability engineering assembles the instructions, research data, evidence, examples, tools, constraints, and current state needed for each invocation. Agent Skills package specialized instructions and optional resources into portable, version-controlled directories that an agent can load when relevant.⁶ As an optional extension, the Model Context Protocol (MCP) can standardize how applications connect agents to prompts, resources, and tools.⁷

   Example: An agent loads the ACORN skill and receives the relevant ResearchActivity schema, source record, validation results, and allowed tools before proposing a correction. A future MCP server could expose the same authoritative context and deterministic checks through a standard interface.

5. Connected memory preserves useful state across iterations, sessions, or tasks. Memory should be selective and attributable: durable facts, decisions, provenance, and prior results are more valuable than an unfiltered transcript. Its origin, availability, modality, and quality are part of the capability’s data profile. A memory service may be reached through MCP, but the protocol is the connection mechanism rather than the memory itself.

   Example (planned): A later session retrieves a previously reviewed project identity, identifier mapping, and provenance record instead of asking the model to infer them again from conversation history.

6. Agent harness and interoperability orchestrates models, skills, tools, workflows, context, memory, permissions, validation, recovery, observability, and human approval. The harness turns the lower layers into a controlled workflow and owns its budgets and stopping conditions. Its permissions and approval policy shape autonomy, while its perception, state, actions, and feedback shape motivity. As an optional extension, the Agent Client Protocol (ACP) can standardize communication between the harness and external agents, including sessions, streamed updates, and permission requests.⁸

   Example (planned): ACORN launches OpenCode through ACP, sends a hydrated prompt, streams progress, mediates tool permissions, validates the returned suggestion, and asks for human approval before any change is applied.

How IID Shapes ACORN

ACORN exists to maintain, validate, connect, analyze, and communicate research activity data. That work needs trustworthy structure and provenance before it needs autonomy. ACORN therefore keeps schema validation, identifier checks, formatting, linking, and artifact generation deterministic. AI is an optional consumer of—and contributor to—those workflows, not a replacement for their rules.

IID guides ACORN development in five ways:

• Ground intelligence in research structure. ACORN schemas, validators, persistent identifiers, and provenance provide authoritative context and machine-checkable boundaries for model-assisted work.
• Make capability composable. Prompts, skills, model APIs, local-model configuration, and future tools are useful independently and can be combined without forcing every user into a full agent stack.
• Keep agency accountable. Iteration needs explicit exit criteria and budgets; memory needs provenance and lifecycle rules; tools need permissions; and consequential actions need validation or human approval.
• Work locally by default. Deterministic core operations, prompt hydration, and locally available models should continue to work without a remote AI service. Network use must remain explicit and respect ACORN’s offline boundary.
• Keep files authoritative. Research records, .prompt templates, SKILL.md instructions, configuration, and generated artifacts should remain portable. Applications consume or synchronize this state rather than owning its only copy.

Local-first does not mean local-only: ACORN can still synchronize applications and use remote services when selected. It is also distinct from portability, which describes where the complete capability can run after accounting for its model, tool, and service dependencies. File over app does not require every internal value to be a flat file. Databases may provide rebuildable indexes and operational storage, while credentials belong in environment variables or dedicated secret stores rather than portable project files.

MCP and ACP are optional, complementary extension points rather than requirements for IID. MCP answers what context and capabilities an agent can access; ACP answers how a client communicates with and supervises an agent. Skills remain portable instruction and resource packages independent of both protocols. A system can implement context engineering or an agent harness without MCP or ACP. The protocols also do not replace model APIs, which provide direct model invocation.

Current ACORN Support

The table reports ACORN’s implementation coverage for each IID layer. It does not score ACORN’s maturity or imply that every workflow should use every layer.

The sequence is composable, not all-or-nothing. ACORN can strengthen each layer independently—for example, by adding prompt evaluation before workflow execution, exposing deterministic ACORN operations as tools before granting broader agency, and defining memory provenance before retaining agent state. The result should be an agentic ACORN whose intelligence grows in depth without weakening the dependable research infrastructure at its core.

1. National Institute of Standards and Technology, “defense-in-depth,” Computer Security Resource Center Glossary. The glossary traces the definition to CNSSI 4009-2015 and multiple NIST publications, including SP 800-53 Rev. 5. ↩

2. Martin Kleppmann, Adam Wiggins, Peter van Hardenberg, and Mark McGranaghan, “Local-first software: You own your data, in spite of the cloud”, Ink & Switch, 2019, doi: 10.1145/3359591.3359737. ↩

3. Steph Ango, “File over app”, 2023. ↩

4. Google, Dotprompt specification and Dotprompt reference documentation. ↩

5. Anthropic, “Building effective agents”, 2024. ↩

6. Agent Skills, Specification. ↩

7. Model Context Protocol, “Architecture” and “Server features”. ↩

8. Agent Client Protocol, “Architecture”. ↩