// constrain the agent, not the intelligence

NOETIC

Build AI agents you’d actually trust in production.

Noetic gives you composable TypeScript primitives, context that keeps token costs flat, and evals that catch regressions before users do.

$ bun add @noetic-tools/core(npm · pnpm)
Build your first agent →GitHub ★
01 · COMPOSE
It's just TypeScript.
Seven primitives you read, fork, and own.
02 · REMEMBER
Context that doesn't blow up.
ten context layers keep token costs flat.
03 · ENDURE
Survives production.
Checkpoint and resume — Node, browser, or sandbox.
04 · PROVE
Prove it works.
Score and optimize like Jest tests.
react-agent.ts
import { AgentHarness, any, callModel, loop, until } from '@noetic-tools/core';

const agent = loop({
  id: 'react-loop',
  steps: [callModel({ id: 'think', model: 'openai/gpt-4o', tools: [searchTool, calcTool] })],
  until: any(until.noToolCalls(), until.maxSteps(10)),
});

const harness = new AgentHarness({
  name: 'researcher',
  agentGraph: 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.

LOOPpromptllmtoolrun✓until
LEGEND
steps
operators
callModel

Call a language model

(params: ModelParams) => Step
invokeTool

Invoke an external tool

(name, input, fn) => Step
runCode

Execute a pure function

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

Launch a child agent

(agentConfig) => Step
inParallel

Parallel step execution

({ mode, paths }) => Step
conditional

Conditional step selection

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

Repeat steps until condition

(steps[], until) => Step
// compose it yourself

Patterns are just compositions

Common agent patterns in a few lines of the same primitives — no pattern library to learn.

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 patternthought → action → observeinputthoughtactionOBSERVE✓answer
ReAct~15 lines

Reason, act, observe loops

loopcallModelinvokeTool
Ralph Wiggum~10 lines

Retry with feedback until a verifier passes

loopspawncallModelinvokeTool
Task Trees~40 lines

Parallel sub-agent hierarchies

inParallelspawncallModel
Thread Weaving~25 lines

Interleaved parallel workstreams

inParallelcallModelrunCode
Dual Agent~20 lines

Critic + generator collaboration

inParallelchannelrunCode
// read the source

Reasoning loop in 15 lines, full context 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, callModel, loop, until } from '@noetic-tools/core';

const reasonAndAct = loop({
  id: 'react-loop',
  steps: [
    callModel({
      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 context 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.

write ↓↑ readWORKING MEMORYcurrent turnOBSERVATIONALauto-extracted factsSEMANTIC RECALLvector storeEPISODICconversation summariesDURABLE STATEagent checkpointsLLMassembleView()raw history ≈ 6,000 tok → assembled context ≈ 680 tok
LEGEND
working layers
retrieval layers
persistence
Working Memory
Scratchpad for the current turn
Observational Context
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 Context
Recall of prior tool calls and results
Temporal Context
Time-stamped fact extraction and recall
Plan Context
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.