Technology
The technology behind Forge and Forenta Enterprise.
Forge assesses your text at three levels. Forenta Enterprise adds eight stages, with stage artifacts, checklists, tasks, roles and a decision point after every stage. Enterprise runs as a pilot; we check the setup and the controls for each pilot.
The analysis engine
Eight mechanisms, one pipeline.
In the analysis environment each stage has its own mechanism: an instrument that shows what is happening until the stage artifact is locked. The same eight run below, step by step.
Idea
Loose signals are narrowed down to one central question. Goal, scope and assumptions go into a project brief.
The eight development stages
From idea to monitoring, in fixed stages.
Every project runs through the same eight stages. For each stage it is fixed which question is central, which input is needed, what is delivered and what must be done before the next stage starts.
01
Idea
- Question
- What do we want to build, and why?
- Input
- Idea, note or problem statement
- Output
- Project brief
- Gate
- Goal, scope and assumptions captured
02
Research
- Question
- What do we already know, and what is missing?
- Input
- Project brief, sources and a repository (read-only)
- Output
- Research package
- Gate
- Evidence gathered and weighed
03
Analysis
- Question
- Does the rationale hold, and where is the risk?
- Input
- Research package and project context
- Output
- Advisory report
- Gate
- Findings assessed and an explicit verdict
04
Architecture
- Question
- How do we build this, and with what data model?
- Input
- Advisory report and requirements
- Output
- Blueprint
- Gate
- Design and execution plan complete
05
Build
- Question
- Does what we deliver actually work?
- Input
- Blueprint and build prompts
- Output
- Build report
- Gate
- Parts work and are traceable
06
Validation & security
- Question
- Is it correct, secure and ready?
- Input
- Build report and test criteria
- Output
- Test report
- Gate
- Tests, risks and a go/no-go decision
07
Deployment
- Question
- How do we ship this under control?
- Input
- Test report and release plan
- Output
- Release runbook
- Gate
- Release, rollback and checklist complete
08
Monitoring
- Question
- Does it do in production what it should?
- Input
- Release runbook and signals
- Output
- Monitoring report
- Gate
- Metrics and follow-up in place
Processing per stage
Every stage runs the same cycle.
Within a stage, Forenta analyzes the context and writes findings with a verdict. From those follow tasks, a required checklist, a stage artifact and a build prompt. A gate closes the stage. What one stage produces becomes context for the next, so the work builds up instead of starting over.
- 01Context
- 02Analysis
- 03Findings
- 04Tasks
- 05Checklist
- 06Stage artifact
- 07Build prompt
- 08Gate
What a stage delivers
Four concrete results per stage.
Recorded output you can use directly, not loose answers in a chat. The examples below are illustrative.
Stage artifact
One recorded document per stage: project brief, research package, advisory report, blueprint, build report, test report, release runbook or monitoring report.
Advisory report · Analysis Verdict: conditional go Main risk: demand for the product untested
Tasks and recommendations
Concrete, traceable next steps that follow from the findings. Each task belongs to the stage and the artifact it came from.
1. Test demand in 5 user interviews 2. Define the data model for the core entity 3. Cut scope to a single flow
Checklist and gate
A required checklist blocks the stage transition until every item is done. The server and the database enforce this. Overruling a gate is always explicit and recorded in the audit log.
[x] Sources weighed [ ] Assumptions tested Gate blocked: 1 item open
Build prompt
An executable instruction with context and acceptance criteria, ready to paste into your own development environment. You get the task and its criteria, not internal system prompts.
Build the input validation for the sign-up form. Acceptance: empty fields rejected, email checked, errors shown.
Control
Recorded and traceable, with a gate where it matters.
You can check what was decided and why. Incomplete work does not slip through to the next stage unnoticed.
Recorded decisions
Decisions and stage transitions are recorded, so you can check what was decided and when.
Gates that block
Required checks stop an incomplete stage transition. The server and the database enforce this.
Traceable findings
Every finding can be traced to the tasks and artifacts it produces, across the stages.
A person decides
Important decisions are reviewed by a person. Overruling needs a reason and leaves the AI verdict as it was.
Connectors and development environments
What connects today, and how.
In an Enterprise project, connectors provide context and only read; Slack only receives project updates. The organization can also connect MCP sources, Claude Code and Codex. Other AI tools work through a handoff of build prompts, checklists and artifacts.
GitHub
Repository context, read-only: README, languages, branches, recent commits and open issues.
Enterprise
Jira and Confluence
Recently updated issues and pages as project context, read-only.
Enterprise
Note or document
Pasted text, such as architecture notes or decisions, as project context.
Enterprise
Slack
Posts a project update to a channel when you ask. Reads nothing.
Enterprise
MCP sources
Atlassian, Notion, Linear, Asana, GitHub, Sentry, Microsoft Learn or your own MCP server. A new source is read-only, masks email addresses, phone numbers, IBAN, BSN and card numbers, and has every tool off until an admin turns it on.
Enterprise
Claude Code and Codex
With a personal organisation token, both tools read workspaces, projects, tasks and review findings. With write access they report work and evidence, handle findings, tick checks and request a review. Every call is recorded in the audit log.
Enterprise
Other AI tools
Build prompts, checklists and artifacts as Markdown, to paste into your own tool.
Via handoff
Supabase and Vercel
Schema, deployments and environment data as project context, read-only.
In preparation
AI and data
Where AI is used and what happens to your input.
- Where AI is used
- Forge and Flux use Anthropic's commercial API. Optional avatars are generated through fal.ai. Reviews in Forenta Enterprise run on the organization's own model key, from Anthropic or OpenAI. That key is stored in Supabase Vault.
- Which input is processed
- Forge processes only the text you paste. In an Enterprise project, connected sources such as GitHub or Jira can serve as additional evidence.
- Voice input
- The microphone button uses your browser's speech recognition (the Web Speech API). Your browser does the recognition, not Forenta. Chrome sends the audio to Google's servers to do it, so what happens to your voice differs per browser. Forenta receives no audio, only the text you choose to keep. That text reaches Anthropic only when you ask Flux to structure it. If your browser does not support the API, the button does not appear.
- Where processing happens
- Core data is intended for an EU region of Supabase and the app runs on Vercel. Anthropic and fal.ai may process input in the United States, so not all processing stays in the EU. If you use the voice button, your browser's speech service is added to that.
- Human control
- Important decisions are reviewed by a person before they are made. Overruling always needs a reason, is recorded in the audit log and leaves the AI verdict as it was.
- Retention and training
- Forenta does not train its own models on your content. Anthropic states that commercial API data is not used for training by default and is normally removed from its backend within 30 days, subject to safety, legal and contractual exceptions.
- AI can be wrong
- AI output can contain errors and unfounded assumptions. Read it critically and use the reviews and gates to check it.
More on data processing and safeguards: privacy policy and trust and data.

From analysis to a route you can carry out.
Start with an idea, a text or a piece of code. Forge assesses it. With Forenta Enterprise, stage artifacts, checklists, tasks and build prompts for your own development environment follow.