Blocks is our library of production-tested agentic patterns - planning, reflection, tool use, ReAct, orchestration, human-in-the-loop. Compose them into an agent instead of hand-writing a reasoning loop for every new project.
Planning, reflection, tool use, a ReAct loop, an approval gate - the same handful of patterns sit inside almost every agent worth shipping. Most teams hand-write them from scratch each time, and rebuild the same bugs along the way.
Each new agent starts with someone re-implementing planning, retries, tool-calling and a reason-act loop by hand. The interesting, domain-specific part ships buried under scaffolding a hundred teams have already written a hundred times.
The loop that looked flawless on a happy-path demo has no reflection step, no escalation gate and no test suite behind it. It meets a real edge case in week two, and there's nothing underneath to catch the fall.
Because every agent's internals are bespoke, nothing is reusable, nothing is evaluated the same way twice, and governance is applied - or forgotten - case by case. There's no library to build on, only a growing pile of one-offs.
Blocks packages the agentic patterns worth reusing - each one configured to your models and tools, tested with eval cases, and governed the same way underneath. Compose them; don't rewrite them.
Decompose a goal into an ordered set of steps, then execute them. The agent writes the plan before it acts, so a complex task becomes a sequence you can inspect, resume and audit - not one opaque prompt.
The agent drafts, critiques its own output against your criteria, then revises before returning. Self-correction catches the mistakes a single pass makes - the missing filter, the wrong unit, the unstated assumption.
Reason about which system to call, call it through MCP, a REST API or a function, and use the result. Blocks handles the tool contract, the arguments and the observation, so the agent acts on live data, not a stale guess.
Interleave reasoning and action in a loop - think, act, observe, repeat - until the task is solved. It's how an agent works through a problem it can't answer in one shot, one grounded step at a time.
Chain specialized agents into a pipeline, each handing its output to the next - extract, then validate, then summarize. Specialists in sequence beat one generalist doing everything at once.
Bring a person in exactly where the stakes require it - an approval, a review, an escalation. Set the condition, and the agent pauses for a human decision that's captured to the audit trail.
Pick a pattern, read how it's structured, then play its execution trace step by step. This is an illustration of how each Block reasons and acts - not a live model call.
Break a big goal into ordered steps, then execute them.
Press Play trace to stream this pattern's reasoning and actions, step by step.
Six patterns, one governed runtime - compose them into an agent, or let Forge compose them for you.
A Block goes from the library to production the same way every time - configured, composed, evaluated and governed before it ever ships.
Choose the pattern that fits the job - planning, ReAct, reflection or another. Start from a tested primitive instead of a blank file.
Wire in your model, your tools and your prompt. The pattern's structure stays fixed; what it reasons over is entirely yours.
Nest and chain patterns into the agent you actually need - a ReAct loop that uses tools, wrapped in reflection, gated by a human step.
Run the composed agent against your test cases. Blocks are built to be measured, so reliability is a number you can see, not a hope.
Sentinel applies guardrails, eval gates and an audit trail to every pattern and every run - governance as a property of the Block.
Deploy inside Forge, in your own cloud - as an API, a job or a step in a larger workflow. Versioned, observable and yours to change.
Blocks isn't a model or a product - it's the layer of proven patterns underneath them. You compose from the library; Forge runs the composition over your models, tools and data; Sentinel governs the whole thing.
Deployed inside your cloud and your security perimeter - your patterns, your data and your logic never have to leave to run.
Patterns aren’t used alone - they nest and they stack. A tool call sits inside a ReAct loop; the loop is wrapped in reflection; the whole thing is gated by a human step. The same primitives compose upward into Forge workflows and the products your users see.
A tool call inside a ReAct loop, wrapped in reflection, gated by a human approval - one governed agent, composed from four patterns.
Blocks is the library underneath the multi-agent systems Focaloid ships today - the reason a reliable agent is composed in weeks, not invented from scratch.
Thousands of CVEs, triaged by a pipeline of specialized agents - one plans the investigation, others use tools to pull advisories and match affected versions, a sequential hand-off assembles the assessment. Triage that took analysts hours now runs in minutes. It’s Planning, Tool use and Sequential orchestration, composed from the library.
The identical building blocks sit behind the media-monitoring and NLP agents that read and summarize at scale, and the document and finance agents that extract, validate and reconcile. Different domain, same tested primitives underneath - composed to each.
Reach for the pattern that matches the shape of the work - and remember that most real agents combine a few of them.
Multi-step research, board summaries, analyses - anywhere the agent needs a plan before it acts and a result you can trace back to its steps.
Investigations, diagnostics and data lookups where the agent has to think, query, read the result and decide the next move, one grounded step at a time.
Drafting, code and content generation, quality review - anywhere a self-critique-and-revise pass turns a rough first answer into one you’d actually send.
Order status, account updates, live data - whenever the agent has to reach into a real system through MCP or an API rather than reason in a vacuum.
Document processing, data enrichment, back-office flows - work that’s naturally a chain of specialized stages, each handing off to the next.
Refunds, approvals, underwriting, anything over a threshold - decisions that need a person’s sign-off, captured with the evidence for the audit that follows.
There are plenty of ways to sketch an agent loop. Fewer are built so you’d run a regulated process on the result - and hand it to your own team afterward.
Every pattern is one we run in production, not a diagram from a paper. You start from primitives that have already met real edge cases and survived them.
Nest and chain patterns freely, and swap the model underneath - Claude, open-weight, fine-tuned - without touching the structure that makes them reliable.
Guardrails, eval gates and a full audit trail come standard through Sentinel, applied to every pattern and every run - not bolted on when compliance asks.
Blocks are built to be measured. Reliability is a number from your own test cases, checked before deploy, not a claim from a one-off demo.
The patterns run in your cloud, composed inside Forge, defined in your repo. No dependence on us to change an agent once it’s live.
From the first pattern to a governed multi-agent system in production, it’s one team - the same people who built Forge, Sentinel and Prism.
Two kinds of reusable IP: the tooling we build and govern with, and the solutions that drop straight into a use case. Blocks is the first of the former - the layer everything else on this board is assembled from.
Blocks is the bottom of the stack. Forge composes and runs the patterns, Velocity uses them across the delivery lifecycle, Sentinel governs every one - and Prism and Echo are what they add up to when pointed at a real use case.
Blocks is built for regulated work. ISO/IEC 27001-certified delivery, governance aligned to US frameworks like the NIST AI RMF and the EU AI Act, an audit trail on every run, and deployment inside your own cloud. Every pattern is governed by Sentinel - so an agent composed from Blocks clears the review instead of stalling in it.
How Sentinel governs it →Proven orchestration frameworks, models and evaluation tooling - assembled into a library of patterns, chosen for reliability and fit rather than a logo on a slide.
The exact stack is chosen per engagement - Blocks is framework- and model-agnostic by design, so it can adopt a better pattern or model the day one arrives.
A library, delivered as part of how we build. Blocks is our collection of production-tested agentic patterns; we compose them into your agents - usually inside Forge - and hand the result over. You don’t buy a box; you get agents built from primitives you can keep and change.
Those are excellent frameworks, and Blocks uses them. The difference is what sits on top: patterns we’ve already hardened in production, configured to your stack, tested with eval gates and governed by Sentinel. You get the framework’s power without re-deriving the reliable way to use it for every new project.
Any of them. Blocks is model-agnostic - Claude, open-weight, or your own fine-tuned models - and a pattern’s structure doesn’t change when you swap the model underneath. Use the right model for each step, and change it later without a rewrite.
Every pattern is built to be evaluated. We baseline a composed agent against your real test cases, put eval gates in front of deploy, and trace every run - so reliability is measured before anything ships and watched after it does, rather than assumed.
Every Block runs under Sentinel: guardrails on inputs and outputs, evaluation gates before deploy, access control and a full audit trail on every run. Governance is a property of the pattern, not a checklist someone remembers to apply.
Through Forge. We compose the patterns you need into a workflow, run it in your cloud, and give your team the visual canvas and the definition to change it. Blocks is the library; Forge is how you build and run with it. A focused first agent is a matter of weeks.
Bring us the task - a research pipeline, an approval flow, a document agent. On a 30-minute call we’ll map it onto the patterns it’s really made of, and show you what it takes to compose, govern and ship it.
ISO/IEC 27001-certified · Governed by design · Deploys in your cloud