import { AgentHarness, react } from '@noetic-tools/core';

const agent = react({
  model: 'openai/gpt-4o',
  tools: [searchTool, calcTool],
  maxSteps: 10,
});

const harness = new AgentHarness({
  name: 'researcher',
  initialStep: agent,
  params: {},
});

await harness.execute('Find recent AI news');
const { text } = await harness.getAgentResponse();

01·Compose

// core primitives

Meet the building blocks

A small set of composable primitives. Build any agent pattern by combining the pieces you need.

Reasoning loops, parallel workloads, sub-agents — all of it falls out of these seven. The ReAct pattern is 15 lines. A task tree is 40. You can read both in under a minute.

LEGEND

steps

operators

llm

Call a language model

(params: ModelParams) => Step

tool

Invoke an external tool

(name, input, fn) => Step

run

Execute a pure function

(fn: (ctx) => T) => Step

spawn

Launch a child agent

(agentConfig) => Step

fork

Parallel step execution

({ mode, paths }) => Step

branch

Conditional step selection

(route: (input) => Step) => Step

loop

Repeat steps until condition

(steps[], until) => Step

// ready to use

Batteries included

Common agent patterns built-in for convenience.

Each pattern is a composition of the primitives above — no special cases, no hidden behavior. Read the source. Fork it. The framework doesn't care.

ReAct~15 lines

Reason, act, observe loops

loopllmtool

Ralph Wiggum~10 lines

Retry with feedback until a verifier passes

loopspawnllmtool

Task Trees~40 lines

Parallel sub-agent hierarchies

forkspawnllm

Adaptive Plans~35 lines

Dynamic plan rewriting mid-run

loopbranchllm

Thread Weaving~25 lines

Interleaved parallel workstreams

forkllmrun

Dual Agent~20 lines

Critic + generator collaboration

forkchannelrun

// read the source

Reasoning loop in 15 lines, full memory stack in 10. No boilerplate.

It's the same seven primitives from before. Once you know those, you can read — and change — anything.

react-loop.ts

import { any, loop, step, until } from '@noetic-tools/core';

const reasonAndAct = loop({
  id: 'react-loop',
  steps: [
    step.llm({
      id: 'think',
      model: 'openai/gpt-4o',
      tools: [searchTool, calcTool],
    }),
  ],
  until: any(until.noToolCalls(), until.maxSteps(10)),
});
// Observe → Think → Act — just primitives composed

02·Remember

// context management

Unparalleled memory management

Long multi-turn conversations without blowing up the context window.

Working memory, observation extraction, plan tracking, durable checkpoints, and more — assemble the layers you need or build your own. Token costs stay predictable as conversations grow.

LEGEND

working layers

retrieval layers

persistence

Working Memory

Scratchpad for the current turn

Observational Memory

Auto-extracted facts from the conversation

Steering

Always-on instructions and guardrails

Static Content

Pinned reference material

History Window

Recent turns, trimmed to a budget

File Reference

On-demand file contents

Tool Memory

Recall of prior tool calls and results

Temporal Memory

Time-stamped fact extraction and recall

Plan Memory

Task tree and execution state

Durable Task State

Persistent agent checkpoints

Custom Layers

Build your own — semantic recall, episodic summaries

03·Endure

// production-grade

Built to survive production

The parts that matter once an agent leaves your laptop.

durable

Durable execution

Checkpoint and resume long runs — they survive crashes and restarts.

portable

Runs anywhere

Node, the browser, or a sandbox. Swap the fs and shell adapters for in-memory, remote, or sandboxed backends.

declarative

JSON workflow runtime

Define an agent declaratively as JSON and run it. Same primitives, no code.

04·Prove

// ship with confidence

Eval Framework

Write evals as easily as Jest tests, then let the optimizer make your agent better.

Define what "good" looks like for your agent, run it against a dataset, and let GEPA optimization improve it. Gate regressions in CI. Same primitives. Same runtime. Just a feedback loop added.

eval-framework

  EVAL RUN: agent-quality-v3
  ─────────────────────────────────

  ✓ PASS  responds to greeting          12ms
  ✓ PASS  uses search tool correctly    340ms
  ✗ FAIL  handles ambiguous query       280ms
  ✓ PASS  stays within token budget     890ms
  ✓ PASS  cites sources accurately      450ms

  Results: 4/5 passed (80%)

  GEPA OPTIMIZE ━━━━━━━━━━━━━ +12% accuracy
  baseline saved · regression gate: pass

// the landscape

What makes Noetic different?

LangChain

Magic on the way in. Black box on the way out.

LangGraph

Powerful. Also: now you're a graph theorist.

CrewAI

Works great until it doesn't.

AI SDK

Too magical a primitive to build anything with confidence.

Noetic

Seven primitives. Read it, extend it, ship it — it's just TypeScript.

Any model on OpenRouter — OpenAI, Anthropic, open-weights. Swap models with one line of config.