agenITEarly access →
THE FUTURE OF EMBEDDED DEVELOPMENT · EARLY ACCESS OPEN

From idea to a tested PR —
hardware in the loop.

agenIT remembers your codebase, walks the work from idea to a tested PR, and proves it on real hardware — running on the LLM you already pay for. Your source code never leaves your laptop.

Request early access →▶ See it run on hardware

$ npm install -g @agenit/cli · works with your existing LLM auth · free during early access

Used by teams building on
ClaudeGeminiOpenAIOllamaVS CodeMCP
5
V-Model stages
6
LLM backends
92
Server assets
21
Monorepo pkgs

It remembers.

Your standards, decisions, and naming — recalled on every session.

It ships.

Idea to a tested PR, walked stage by stage with approval gates you control.

On real hardware.

J-Link · CAN/LIN · Saleae — flashed, captured, and decoded in the loop.

Your code stays yours.

Local-first by default. Your LLM, your machine, your contract.

Hardware in the loop

From silicon to a tested PR — without leaving the bench

agenIT speaks to the same probes on your desk. It flashes the board, streams RTT logs, decodes the CAN bus, captures the logic analyzer — then writes the fix, the test, and the traceability that proves it works on real hardware, not just in a chat window.

MCUDev boardyour targetJ-Linkflash · RTTCAN / LINbus captureSaleaelogic decodeagenITthe agentTested PRdiff + green CITraceabilitySWR → file → test
HIL signal coverage
96%
decoded

Of bus + log events on the bench are captured, decoded, and linked to a test — automatically.

Signals it speaks
CAN / LIN frames100%
RTT log lines100%
GPIO / SPI edges98%
Bench → tested PR
30m↓ from 8h

Reproduce on hardware, fix MISRA-clean, add the HIL regression, and ship the evidence pack — in one uninterrupted run.

Illustrative · pilot teams in automotive embedded.

In plain English

What it actually does

You already use an AI. agenIT is the layer around it that makes it useful for real software — the kind that ships, gets tested, and ends up in production.

🧠

Remembers your code

Not a chat. It writes down your style, your decisions, and the names you use, and reads them back into every session. No more re-explaining.

✅

Finishes the job

Walks Plan → Code → Tests → Audit. Stops at approval gates you can move through one click, or auto-approve when the change is small.

🔌

Brings your LLM

Use the one you pay for: Claude, Gemini, GPT-4, or a local Ollama box. Same workflow, same skills — just point at your endpoint.

🔒

Local-first by default

Your source never leaves your laptop. Only the AI's instructions stream in, get used, and get wiped when you're done.

🤝

Squad of helpers, not one chat

Cheap helper models read the codebase in parallel; one capable model writes the answer with that context already in hand. Faster and cheaper.

🛠

Works on what you build

Web app, mobile, CLI, embedded firmware — switch profile, same product. Hardware folks get J-Link / CAN / Saleae built in.

/ How it's different

vs the AI tools you've already tried

CapabilityCopilotCursorClaude CodeagenIT
Memory across sessions—limitedsessionplaintext markdown · git-diffable
Bring your own LLMOpenAIfewAnthropic6 backends incl. Ollama
Code stays on your machinenonoyesyes · plus IP wipe on exit
Finishes the job (Plan→Test→Audit)——manual/run walks it
Approval gates———configurable per stage
Hardware (J-Link / CAN / Saleae)———first-class
Open & inspectablenonopartialopen runner · signed assets
We're not claiming agenIT replaces these — many users run it alongside Cursor or Claude Code.
1
Tell it what you want
“build me a CAN driver” or “add OAuth to the signup page”
2
It plans
writes requirements + decisions you can edit
3
It codes
tags every change against a requirement so nothing is orphaned
4
It tests
writes the tests it would want a junior to write
5
It hands you the PR
with the audit trail. You hit Approve.
Stage 01 · The hurt

Sound familiar?

Most engineering teams already have an LLM. What they don't have is the discipline, memory, and integrations to make it pay back. Here's what agenIT removes from the week.

Where the week goes
% of an engineer's week — before vs with agenIT
beforewith agenIT
Re-explaining context
18%→1%
Traceability & audit
22%→3%
Tool switching
14%→2%
Boilerplate code
16%→4%
Test scaffolding
12%→3%
Actual engineering
18%→87%

Illustrative · based on pilot teams in automotive embedded and regulated SaaS.

“I keep re-explaining our stack to the LLM.”
→Soul + project memory remember your standards, decisions, and naming on every session.
“Traceability is a part-time job nobody wants.”
→Every requirement, file, and test is linked automatically. /audit produces the matrix on demand.
“Our LLM lives in a chat window, not in our process.”
→REPL + V-Model state machine + approval gates turn the model into a teammate, not a toy.
“We can't send proprietary code to a public API.”
→Bring your own LLM (Gemini, Claude, on-prem, vLLM). Memory + code stay on your machine.
“Our toolchain is fragmented — DOORS here, Jira there, J-Link on a lab PC.”
→MCP servers + skills bridge ALM, debuggers, logic analyzers, CI, and chat into one shell.
“Agents work for 20 minutes then forget the project.”
→File-locked markdown memory + decay/graph keep context durable across days and squad members.
Stage 02 · A day in the life

02:14 AM — pager goes off.

Same incident, two worlds. The example below is from an embedded team — but the shape is identical for SaaS: a stale on-call, a ticket nobody can root-cause without waking three more people, a fix that lands without tests. agenIT wakes the squad instead of the team.

embedded · automotivealso fits → SaaS on-call · MedTech firmware · platform infra
/ Without agenIT
elapsed: 6h 42m

The pager war-room

  1. 02:14
    PagerDuty
    Pages on-call. On-call is the firmware lead — wrong domain.
  2. 02:31
    On-call
    Wakes the SW architect to triage. Architect needs the requirements engineer to confirm spec intent.
  3. 03:08
    Architect
    Wakes the test lead — last regression run was on a stale branch. Lead can't reach the J-Link rig in the lab.
  4. 03:55
    Test lead
    Pulls the integration engineer out of bed to forward the Saleae trace from the lab PC.
  5. 04:40
    All four
    Stuck waiting on each other in a Teams call. Nobody has the audit trail to know what changed since v2.3.1.
  6. 06:20
    Manager
    Joins to escalate. Asks for traceability matrix that hasn't been updated since last sprint.
  7. 08:56
    Patch
    Lands without tests. Compliance evidence comes Monday — maybe.
5
engineers woken
0
tests added
1
blamey postmortem
/ With agenIT Mission Squad
elapsed: 18m

The squad wakes — humans sleep

  1. 02:14
    webhook → /goal
    Ticket lands. agenIT spins up the squad with the failing trace, recent commits, and matching SWR.
  2. 02:15
    codebase-mapper
    Phase 1 · scans the repo, identifies the affected component and its @req tags.
  3. 02:16
    dependency-grapher
    Phase 1 · pulls the call graph and decisions.md entries for the surrounding subsystem.
  4. 02:18
    test-gap-scanner
    Phase 2 · finds the missing regression in tests/integration — that's why this slipped.
  5. 02:21
    implementer (planner)
    Phase 3 · drafts the fix on a worktree, tagged @req SWR-014, ADR added to decisions.md.
  6. 02:26
    /swe5
    Regenerates unit + integration tests, runs them against the J-Link rig — all green.
  7. 02:30
    /swe6
    Regenerates traceability.json, attaches the evidence packet, opens a PR awaiting one human approval.
  8. 07:45
    engineer
    Wakes up, reviews diff + traceability over coffee, hits Approve. Done.
0
engineers woken
100%
trace + tests included
1
approval, then merged
The founding decision · Local-first IP

Your code stays on your laptop.
The intelligence comes to you.

Most AI dev tools want your codebase on their servers. Fine for a side project — not fine if you work on anything proprietary. agenIT flips it: the tool runs on your machine, the AI's instructions come to you, and they're cleared from disk when you're done. The wire only carries your licence going out and the AI's skills coming in. Your source code? Never moves.

YOUR LAPTOP🔒 Your codestays here · alwaysagenIT CLIruns on your machineLocal sessionauto-cleared when you're doneYour LLMClaude · Gemini · GPTor local Ollamayour endpoint · your authAGENIT CLOUDLicence checkconfirms your subscriptionAI playbooksdelivered on demandOptional team servicesaudit log · usage · SSOlicence pingAI playbooks deliveredpromptcode blocked

The wire only carries a quick licence check going out, and the AI's playbooks coming in. Your code, your prompts, and your memory stay on your laptop.

Open & inspectable

The runner is open and auditable. You can lock it to a specific release and verify the signature.

Just-in-time delivery

AI playbooks arrive when a session needs them and never sit on your disk between runs.

Cleared when you're done

Anything we deliver is removed from your machine the moment you close the session.

Air-gap option

Point at a local model (Ollama) and a local cache and run fully offline. Nothing leaves your network.

Stage 03 · Directional numbers

What pilot teams are seeing

Three lenses on the same shift: time-to-resolve, what ships with each release, and how much throughput a squad gains in a sprint. These are directional averages from early-access teams — not a guarantee, not a marketing number.

Mean Time to Resolve
Minutes per stage of an incident · lower is better
Total: 8h 0m → 30m
Triage
95m→6m
Reproduce on HW
70m→4m
Fix + MISRA-clean
110m→12m
Tests + HIL regression
75m→5m
Evidence + audit pack
130m→3m
Release evidence packet
What agenIT auto-generates for every audit
95%
auto
  • Traceability matrix100%
  • MISRA / OWASP report100%
  • Test coverage XML95%
  • Change log + diffs100%
  • Risk + impact note80%
  • Reviewer narrativemanual
Team throughput
Per squad, per sprint · pilot averages
Tickets / week
17↑ 325%
was 4
Lead time (h)
6h↑ 84%
was 38h
Coverage (%)
89%↑ 65%
was 54%
Approval gates
7↑ 250%
was 2

Directional · averaged across early-access teams in automotive embedded and regulated SaaS. Detailed pilot report available under NDA.

Stage 04 · What makes it work

Built for real engineering

Eight pillars that turn an LLM into a disciplined engineering teammate — not a chat window.

Memory

Profile-Driven Co-Pilot

Onboards once, remembers your stack, standards, and decisions. Soul + per-project memory keep context across every session — no more repeating yourself.

Process

ASPICE V-Model FlowGraph

Five stages, six commands (/swe1–/swe6), one /run that walks them. Each stage writes a real file (requirements.md, decisions.md, traceability.json) and stops at a configurable approval gate.

Backends

Bring Your Own LLM

Six backends: Gemini CLI (default, free OAuth), Claude CLI, Antigravity (agy), Anthropic SDK, OpenAI, and Ollama for air-gapped. agenIT picks per config — no vendor lock-in.

Agents

Mission Squad

Parallel helpers in phases — research (codebase-mapper, pattern-finder, dependency-grapher) → critique (security-reviewer, test-gap-scanner, complexity-grader) → synthesis. Workers on cheap models, planner on capable.

Hardware

Hardware-in-the-Loop

First-class JLink, CAN/LIN, and Saleae Logic 2 integration. Arduino-as-HIL turns dev boards into test nodes for real embedded validation.

Extensibility

Marketplace & MCP

Unified marketplace for MCP servers, Claude skills, and Gemini extensions. Compose your toolchain without forking the CLI.

Spec

Spec-Driven Development

Nine-phase SpecKit pipeline takes you from constitution to issues, with PMO standards enforcement and budget tracking built in.

Autonomous

Overnight Autonomy

/overnight runs a git-backed Plan → Code → Test → Evaluate loop with worktree parallelism and per-iteration rollback safety.

Stage 05 · Plan → Code → Tests → Audit

From idea to a finished PR

Most AI tools stop after "here's some code". agenIT keeps going — it writes down what you wanted, decides how, codes it, tests it, and checks that everything ties back. Each step writes a real file in your repo and pauses for a quick Approve.

Under the hood it's the ASPICE V-Model — the same workflow safety-critical teams use. You don't have to care about that to use it.

Stage 1requirements.md
/swe1
Requirements
Extracts an SWR-NNN registry from your spec — every item gets a stable ID you can trace later.
Stage 2decisions.md
/swe2
Architecture
Records ADR-style decisions for components, interfaces, and trade-offs you commit to.
Stage 2decisions.md
/swe3
Detailed design
Drills into component design and refines the same decisions.md with module-level intent.
Stage 3source + @req
/swe4
Implementation
Writes code tagged @req SWR-NNN against your requirements — traceability happens at write-time.
Stage 4tests/
/swe5
Testing
BDD scenarios, unit tests, integration tests — generated per profile (embedded, web, mixed).
Stage 5traceability.json
/swe6
Audit
Regenerates the traceability graph: every SWR → file → test, with gap report and evidence packet.
/ V-shape · command map
Which slash command runs at which stage — and the artifact it produces.
design ↘↗ verification
/swe1requirements.mdSWR registry/swe2decisions.mdADRs/swe3decisions.mdComponent design/swe4source + @req SWR-NNNImplementation/swe5tests/unitUnit tests/swe5tests/integrationIntegration tests/swe6traceability.jsonAudit + evidenceDESIGN ↘↗ VERIFICATION

Dashed lines pair each design artifact with the verification artifact that proves it. agenIT enforces the pairing — /swe6 regenerates traceability.json and fails if any SWR-NNN isn't linked to a file and a test. Type /run to walk the whole chain end-to-end with approval gates.

Stage 06 · Fits your toolchain

One shell for the whole stack

ALM (Codebeamer, DOORS, Polarion, Jama), PM (Jira, ADO), CI (Jenkins, GitLab), debuggers (J-Link, Lauterbach, OpenOCD), bus & logic (Saleae, PEAK, Vector), IDEs, and chat — all reachable from one REPL via MCP servers and skills.

  • ● Native MCP
  • ● ReqIF round-trip
  • ● CI webhooks
  • ● HW Python bridge
cbDPJJkGLJLSVSSlNS3agenITyour co-pilot
cb
CodebeamerALM
REST + traceability sync
D
IBM DOORSALM
ReqIF import / export
P
PolarionALM
Work-item bridge
JC
Jama ConnectALM
J
JiraPM
MCP + webhooks
AZ
Azure DevOpsPM
Jk
JenkinsCI
GL
GitLab CICI
JL
SEGGER J-LinkDebug
Flash + RTT
L32
Lauterbach TRACE32Debug
OC
OpenOCDDebug
S
Saleae Logic 2HW
Capture + decode
PK
PEAK CANHW
CAN / LIN
V
Vector CANoeHW
VS
VS CodeIDE
Skills + REPL panel
JB
JetBrainsIDE
Nv
NeovimIDE
Sl
SlackComms
Job notifications
T
MS TeamsComms
Cf
ConfluenceDocs
N
NotionDocs
MCP
S3
S3 / MinIOData
cb
CodebeamerALM
REST + traceability sync
D
IBM DOORSALM
ReqIF import / export
P
PolarionALM
Work-item bridge
JC
Jama ConnectALM
J
JiraPM
MCP + webhooks
AZ
Azure DevOpsPM
Jk
JenkinsCI
GL
GitLab CICI
JL
SEGGER J-LinkDebug
Flash + RTT
L32
Lauterbach TRACE32Debug
OC
OpenOCDDebug
S
Saleae Logic 2HW
Capture + decode
PK
PEAK CANHW
CAN / LIN
V
Vector CANoeHW
VS
VS CodeIDE
Skills + REPL panel
JB
JetBrainsIDE
Nv
NeovimIDE
Sl
SlackComms
Job notifications
T
MS TeamsComms
Cf
ConfluenceDocs
N
NotionDocs
MCP
S3
S3 / MinIOData
Stage 06b · Your LLM, your auth

Six backends. Zero lock-in.

Already pay for Claude? Use it. Have a Google Workspace account? Free tier works. Air-gapped lab with an Ollama box? That works too. Flip one line in agenit.toml — the V-Model, the squad, and every skill keep working.

gemini-clidefault
OAuth · Google

Free tier plus Pro/Ultra Google accounts. Spawns gemini -p ... as a subprocess. No API key needed.

claude-clisubscription
OAuth · Claude.ai

Reuses your Claude.ai Pro / Max / Team / Enterprise login. Trusts the CLI's built-in tools.

antigravity-clinext-gen
agy · OAuth or API

Google's successor to gemini-cli after 2026-06-18. Skills folder layout: .agents/skills/*.md.

anthropic-sdkAPI key
Messages API

Direct API path for headless CI and machines without the claude binary. Set ANTHROPIC_API_KEY.

openaiAPI key
Chat Completions

Cross-provider parity. Useful for benchmarking the same prompt across models.

ollamaair-gapped
Local HTTP

Zero outbound traffic. Pair with the local orchestration cache for a fully offline install — no licence check on each run.

// agenit.toml
[backend]
provider = "claude-cli"      # gemini-cli · claude-cli · antigravity-cli
                              # anthropic-sdk · openai · ollama
worker_model  = "haiku"      # squad helpers — cheap tier
planner_model = "sonnet"     # primary agent — capable tier

[squad]
auto_squad = true
max_concurrent_agents = 4
Stage 07 · Under the hood

Three layers. Clear contracts.

A stateful TypeScript CLI drives your chosen LLM, which delegates to a Python bridge for hardware and heavy parsers.

1
Layer 1

agenIT CLI

Runs on your machine
  • ▸REPL, slash commands, autocomplete, history
  • ▸V-Model workflow with approval gates
  • ▸Local persona + project memory
  • ▸Parallel helper agents · autonomous goal loop
  • ▸Local code search
2
Layer 2

Your LLM

Your choice · your contract
  • ▸Skill auto-activation by intent
  • ▸Standard tools: read, write, shell
  • ▸Pre/post hooks you control
  • ▸MCP server bridging
3
Layer 3

Hardware & docs bridge

Python sidecar
  • ▸JLink flashing + RTT log streaming
  • ▸CAN / LIN bus capture + decode
  • ▸Saleae Logic 2 captures
  • ▸PDF / Excel / Word ingest
Stage 08 · Try it

Touch the REPL

A mock of the agenIT REPL so you can feel how it works before installing. Type a slash command or anything in free form — outputs are simulated, but the flow is the real one.

  • ▸ Mock REPL wired to the headline slash commands
  • ▸ History with ↑/↓ · clear with ⌃L
  • ▸ Free-form prompts route to the best skill in the real REPL
demo.mp4 · 1:021080p · captions
Get the real CLI · Request early access →
agenIT·flow[*demo-project]
* SYSTEM
agenIT — profile-driven AI dev co-pilot.
Type a question, or /help for commands.
[demo] flow>
try:
Stage 09 · The vocabulary

92+ slash commands

A REPL designed like an OS shell — every workflow, integration, and persona is one command away.

V-Model
/run/swe1/swe2/swe3/swe4/swe5/swe6
Autonomous
/goal/squad/agent/jobs
Memory
/memory/soul/global/graph
Backends
/backend gemini-cli/backend claude-cli/backend ollama/backend openai
Hardware
/jlink/can/logic2/gdb
Tools & MCP
/mcp/skill/recipe
Stage 10 · PMO & budget control

Sprints, budgets, and PMO standards — built in

agenIT isn't just a code co-pilot. It ships with a Project Management Office layer that plans sprints, tracks budgets, enforces standards on every activation, and reports back without anyone opening a spreadsheet.

Sprint planning

Plan, slice, and assign

/sprint plan turns a goal into stories, slices them into squad-sized tasks, and assigns each to the right agent — with story points and dependencies.

Budget control

Token + time budgets

Every goal carries a turn budget and an LLM-token budget. /goal status shows burn-down per stage; agenIT stops at the gate when budget is depleted.

PMO standards

Standards on activation

PMO templates (naming, commit style, doc layout, branch policy, license header) are loaded with the profile and enforced via pre-tool policy hooks.

Sprint review

Automatic review packet

/sprint review compiles velocity, burn-down, requirement coverage, MISRA findings, and per-agent metrics into a single markdown report.

Risk + impact

Risk before merge

/risk runs an impact analysis against the traceability graph and flags downstream tests and requirements affected by the change.

Reporting

Status without spreadsheets

/report rolls up tasks, approvals, decisions, and budget across projects — exportable to Confluence, Notion, or your SIEM.

/ Sprint burn-down
Sprint 14 · 10 working days · 84 story points planned
on track
/ Goal budget gauges
GOAL-20260527003238-d53f · DIO Driver for S32k118
Turn budget
18 / 50 turns
Token budget
412k / 800k tokens
Time budget
41m / 2h wall time
Approval gates
4 / 7 cleared
✓ all budgets nominal · /goal continue
Stage 11 · Marketplace

A platform, not a binary

Five flavours of extension — Skills (what the AI can do), Plugins (where it lives — VS Code, JetBrains, Slack, CI), Tools (MCP servers for your toolchain), Profiles (full preset bundles), and Recipes (one-shot prompt chains). Install with a slash command. Publish your own.

Skills
6+

misra-c-2012 · owasp-asvs-audit · tdd-loop

browse →
Plugins
6+

vscode-repl · slack-jobs · github-actions

browse →
Tools
8+

codebeamer-mcp · jlink-bridge · jira-issues

browse →
Profiles
4+

automotive-ecu · saas-typescript · medtech

browse →
Recipes
3+

migrate-doors-to-ears · rewrite-as-tdd

browse →
Browse the marketplace →Publish your own ↗
92 server-side assets in production · open submission queue
Stage 10 · For decision makers

Bring your LLM into your world.
Not the other way around.

You already pay for an LLM. The added value isn't more tokens — it's orchestration, memory, governance, and integration that turn the model into an accountable engineer inside your existing process.

BYO

Bring Your Own LLM

Plug in Gemini, Claude, GPT-4.1, Azure OpenAI, AWS Bedrock, on-prem vLLM or llama.cpp. Same skills, same REPL, your endpoint.

VPC

Data sovereignty

Memory, code, and prompts stay in your VPC or on the developer's machine. No telemetry, no training-on-your-data clauses.

GOV

Skill governance

Sign and pin skills, MCP servers, and extensions. PMO templates enforce coding standards and budget at activation time.

LOG

Audit-ready by default

Every approval, tool call, and file write is logged. Export to your SIEM. Reproduce any artifact from the memory snapshot.

/ Data flow

Your data stays on your side

step 1
Your repos & specs
Codebeamer · DOORS · Git · S3
step 2
Local memory
Persona · project memory · code search
step 3
agenIT CLI
REPL · V-Model · approvals
step 4
Your LLM endpoint
Gemini · Claude · vLLM · Bedrock
step 5
Audited artifacts
commits · traceability · SIEM

Prompts go from your machine directly to the LLM endpoint you configured. agenIT never proxies your code or stores your prompts.

Stage 11 · Trust

No black box. No surprises.

Built for teams that can't afford to leak code or trust opaque vendors. Every layer is local-first, inspectable, and consent-gated.

Local-first memory

Persona, project memory, and code search index live on disk under your repo or $HOME — never uploaded by agenIT.

Your model, your contract

We orchestrate; we don't proxy. Your prompts go directly from your machine to the LLM endpoint you configured.

No covert telemetry

Zero analytics by default. If you opt in to anonymous usage stats, the schema is documented and inspectable in the portal.

Pinned, signed components

Lock agenIT to a build, sign skills, pin MCP versions. Nothing updates without your explicit approval.

Air-gapped option

Run fully offline with a local model (Ollama / vLLM) and local MCP servers — JLink, Saleae, filesystem, git.

Granular consent gates

Every shell command, file write, and external call passes through a hook chain you control.

0
lines of your code uploaded to agenIT servers
100%
of memory stored in plain markdown on your disk
Yours
model, repo, prompts, and approval gates
Stage 12 · See yourself

Where teams ship with agenIT

Automotive

Automotive ECU development

AUTOSAR / CAN / LIN drivers with ASPICE-compliant traceability from CRS to test report. Bootloader, UDS, OTA — all profiled.

MedTech · Aero

Safety-critical firmware

MISRA / CERT-C aware code, HIL validation loops, audit-ready evidence packets for IEC 62304, DO-178C, ISO 26262.

Tooling

Requirements migration

Import legacy DOORS / Codebeamer / Polarion baselines into EARS, generate gap analysis, push back enriched items.

R&D

Long-running autonomous loops

Overnight /goal Plan → Code → Test → Evaluate cycles with deterministic rollback and per-iteration approval.

Embedded

Hardware bring-up & triage

Connect a J-Link or Saleae and let the squad reproduce flakey signals, bisect commits, and write the regression test.

Regulated

Compliance evidence packets

Auto-generate traceability matrices, MISRA reports, OWASP audits, and a release dossier reviewers actually accept.

SaaS

Web & product teams

Same V-Model discipline, swapped profile: user stories, Playwright tests, OWASP / a11y audits, Lighthouse budgets.

Internal Tools

Platform & DevEx

Ship internal skills, MCP servers, and PMO templates so every team inherits standards without retraining.

We tried Cursor and Claude Code first. What we kept was agenIT — because we couldn't ship the actual codebase out, and because every other tool forgot what we agreed on yesterday.
EL
Embedded team lead
Tier-1 automotive supplier · early-access pilot

Quote attributable on request · pilot under NDA.

Pricing

Simple, while we're in early access

Free during early access. Pay only when you'd notice we stopped working. No card needed today.

Early access
Freewhile in beta
  • ✓Full CLI + V-Model + Mission Squad
  • ✓Any of 6 LLM backends · BYO auth
  • ✓All Official skills + Tools
  • ✓Community support
  • ✓Local-first IP protection
Request access →
POPULAR
Pro
$29/ seat / month at GA
  • ✓Everything in Early access
  • ✓Private skills / plugins / profiles
  • ✓Signed releases + version pinning
  • ✓Email support · 1-business-day SLA
  • ✓Audit-trail export to SIEM
Get notified at GA →
Enterprise
Customlet's talk
  • ✓Everything in Pro
  • ✓Air-gapped install · self-hosted assets
  • ✓SSO (SAML / OIDC) · SCIM provisioning
  • ✓DPA · custom retention · BAA available
  • ✓Named architect + Slack channel
Contact sales →

Final GA pricing may change · all plans local-first by default · LLM token costs are paid to your model provider, not to agenIT

Stage 13 · Get started

Up and running in minutes

The CLI is one npm package. Pick any of the six LLM backends and bring your own auth — Google OAuth, Claude subscription, API key, or a local Ollama box.

  • ▸ Node.js ≥ 20
  • ▸ One LLM backend (Gemini CLI / Claude CLI / Antigravity / SDK key / Ollama)
  • ▸ Python 3.10+ for the hardware sidecar (JLink, CAN, Saleae — optional)
  • ▸ A licence JWT from portal.agen-it.com (early-access lane is free)
Request early access →
install.sh
# 1. Install the CLI
$ npm install -g @agenit/cli

# 2. Activate with the JWT you got by email
$ agenit activate ~/Downloads/licence.jwt

# 3. Pick a backend (Gemini CLI is the default)
$ npm install -g @google/gemini-cli && gemini auth login

# 4. Walk the V-Model on your project
$ cd my-project && agenit
[my-project] flow> /run requirements/CRS.pdf
   → /swe1  requirements.md         (12 SWR-NNN extracted)
   → /swe2  decisions.md            (ADRs drafted)
   → /swe3  decisions.md            (component design refined)
   → /swe4  source + @req tags      (MISRA-clean)
   → /swe5  tests/                  (unit + integration + BDD)
   → /swe6  traceability.json       (✓ 100% coverage)

Get the AI dev tool with memory

Free during early access. No credit card. Use the LLM you already pay for. We'll email your licence within one business day.

✓ Free during early access✓ No credit card✓ Cancel anytime