The agenticengine
This is not
a coding assistant.
Codeflare runs governed engineering agents inside your own estate. Each change is backed by a spec, proven by tests, documented, and handed to your team to approve, whether that is a pull request to merge or a change to run.
Inference Mesh
Codeflare works with any inference provider. Inference Mesh is one more it can pull from. It turns the idle machines you already own into private, low-cost capacity for your agents. Long-running sessions stay warm, sensitive work never leaves your boundary, and every hosted provider stays first-class, as your default or your fallback.
Velocity
The bottleneck was never typing speed.
A faster autocomplete just gets you to the next decision sooner. Codeflare moves the whole job into one controlled run: you write the requirement, agents prepare the change, and your team reviews the evidence before it executes. The four below are snapshots of a governed run: egress, isolation, review, and spec.
Quality
Spec, tests, and docs, enforced as one.
Every run starts from requirements with acceptance criteria. At the pull request, Codeflare checks the diff against that contract and sends failures back to the agent until the code, its tests, and the docs all agree.
Approve the intent first
Before any code, a requirement and its acceptance criteria are written down. /sdd init bootstraps the repo into that spec-driven framework, backed by a knowledge graph of your code and decisions, so the agent builds against intent you already approved.
Enforcement is a loop
At every PR boundary, spec and TDD enforcers check the diff against its requirements and reject test theater. Findings route back to the agent, which fixes and re-verifies, and nothing merges until the build matches the spec.
Adoption
Legacy code, reverse-engineered into a spec-driven baseline.
Point /sdd init at an existing repo and it reverse-engineers the requirements, acceptance criteria, and knowledge graph an agent needs to work the code without drifting. /sdd clean brings a drifted spec back into line.
Operations
The same agents operate your infrastructure.
The governed harness is not only for code. On the same session model, under your own identity, agents patch servers, migrate workloads, provision clusters, and configure firewalls, proxies, and other appliances. They reach approved targets through your Zero Trust, never a broad VPN, and every action is proposed, approved, and evidenced.
Policy-scoped zero-trust tunnels
Internal hosts, databases, and control planes sit behind zero-trust access policy. A session gets only the routes its group is allowed, never the flat network. No broad VPN grant, and no credential living in the container.
Logged to your tenancy
Every connection and command flows through the same attributed path as model traffic, written to your logs in your tenancy: who reached what, when, and under which policy.
Security
Built on a Zero Trust foundation.
Every dangerous path is closed at the architecture level. A session authenticates through your IdP, runs in an isolated container in your tenancy, and reaches models only through your AI Gateway.
Context
The web, the way an agent reads it.
Heavy pages are mostly chrome an agent can't use. Codeflare loads each one in an isolated, ephemeral browser, runs the scripts, resolves the gate, and returns clean markdown, turning a 1.9 MB page into 12 kB worth reading.
context/automation
From reading pages to driving them.
Hand an agent a deployed flow and a mobile viewport, and the same isolated browser runs the end-to-end test: it navigates, taps, captures each screen, and judges the result against the acceptance criteria.
Control
Agents work inside your pipeline, not around it.
There is no shadow toolchain. Every agent change moves through your git, your CI, and your branch protections, then a panel of specialist reviewers, before a human approves the merge.
Observability
Watch every agent work in real time.
This is the operator's view of the same review: three reviewers on one diff at once, each showing what it's doing and spending as it goes. Follow any one closely, or send the run to the background and move on to the next task.
Cost
Every spend has a known actor.
Codeflare records cost where it is created: container time, browser work, tool calls, and model tokens. Each line rolls up to a user, team, agent, and route in your own estate.
Environment
Containers run in your tenancy, exist only while a session is active, and hibernate to zero when idle. The spend lands in your own estate as line items, not in a vendor black box.
Inference
Model traffic runs through your AI Gateway. Spend is visible by user, team, and group; each group is pinned to its approved models; and traffic fails over automatically when a provider degrades.
Agent tools
Because interception runs below the container, no CLI tool can slip past it. Every token an agent burns lands in the same attributed stream as the rest.
cost/tenancy
Deployed in your own estate.
Codeflare deploys into your own estate, with no vendor in the data path. Source, sessions, and model traffic stay inside your trust boundary, and a guided setup takes a fresh account to a running engine.
Platform
Your context, guidelines, and best practices, preloaded.
A session starts knowing your conventions, your codebase, and your past decisions, not as a blank slate. Skills load on demand and specialist reviewers stand ready, the same way for every supported agent.
platform/runs-everywhere
No client to install. Just a browser.
Codeflare runs in your own estate. The laptop or phone in front of an engineer is only a window onto the session, with no local toolchain to install, patch, or wipe.
Ready in seconds
A full Linux environment with every supported agent preinstalled boots in seconds. No golden images to maintain, no workstation build, no local toolchain to patch.
Access starts in your IdP
Add an engineer to the right group in your identity provider and they are productive on day one. Remove the membership and access is gone the same day, with no device to reclaim or wipe.
Check in from anywhere
Long-running sessions keep working whether you watch or not. Review findings, redirect an agent, or approve the next step from whatever device you have on you.
Continuity
The editor you already know
Visual Studio Code in your browser, running inside Codeflare: the editor you already know, turned into a bird's-eye view across the agent's execution at machine speed. Files change, checks run, the integrated terminal streams, and you stay oriented in a familiar workspace while the work moves faster than you could type it. Take the wheel and edit directly whenever you want.
- codeflare-inference-mesh
- packages
- node-agent
- proxy.go
- runtime.go
- scheduler.go
- router-worker
- README.md
- go.mod
- type ActiveCounter struct {
- value int64
- }
- func (c *ActiveCounter) Inc() {
- atomic.AddInt64(&c.value, 1)
- }
Tooling
Every tool call, attributed to a known identity.
An agent is only as safe as the tools it can reach. Codeflare routes every MCP server through one portal where each call runs as the signed-in user, scoped to least privilege and logged by name. Code mode folds the surface into one typed `code` tool in a sandbox.
Proof
Codeflare built this page.
The page you are reading is REQ-LANDING-001 in the Codeflare spec. It shipped through the same spec, test, and review gates described above, and every anchor below points at the real file.
In good company
FAQ
The answers, up front.
Where does our code and data live?
Inside your own estate. Workspace storage uses your object-storage buckets, metadata your key-value store, and sessions run in containers under your tenancy. Codeflare is software you operate, so we never hold your code. Storage is encrypted at rest, with customer-provided key options.
How do agents reach LLM providers?
Not directly. All model traffic is intercepted at the platform layer and routed through your AI Gateway with your keys, where guardrails and DLP apply. You pick approved models per group, set rate limits, and see attributed spend. Provider outages fail over automatically, and provider credentials never enter the container.
Do we have to use the Inference Mesh?
No. Codeflare works with any hosted inference provider as your default or your fallback, routed through your AI Gateway. The Inference Mesh is one optional additional source: it turns idle machines you already own into private, low-cost capacity, so long-running or sensitive work can stay inside your boundary. Run entirely on hosted providers, entirely on the mesh, or mix the two per group.
How does authentication work with our IdP?
Through zero-trust access in front of every surface, federating to Entra ID, Okta, Google Workspace, or any SAML/OIDC provider you already run. Provisioning is group membership; offboarding is group removal.
What stops an agent from escalating privileges?
Hard infrastructure boundaries. Each session runs in its own ephemeral container behind zero-trust access, with no peers to move to and no standing infrastructure to persist on. When the session ends, the container is destroyed.
Can agents operate infrastructure, not just write code?
Yes. The same governed session that builds also patches servers, migrates workloads, provisions clusters, and configures firewalls, proxies, and other appliances. It reaches approved targets through your Zero Trust, never a broad VPN, and every action is proposed, approved, and evidenced before it touches a host, with no standing credentials left behind.
Which agents are supported?
Claude Code, OpenAI Codex, GitHub Copilot, Pi, Google Antigravity, and OpenCode, selectable per session with the same isolation and governance regardless of choice.
What does it cost to run?
Pay-per-use on your own bill: container minutes while sessions run, storage per byte, and your negotiated model rates through the AI Gateway. No per-seat licenses, no idle fleet, and no vendor margin on your inference.
Does this replace our existing SDLC tooling?
It works through your existing tooling rather than replacing it. Agents commit through your git, run your CI, and obey your branch protections; the review pipeline layers extra gates on top and removes none of yours.
get-started
Deploy Codeflare in your environment.
New to engineering agents, scoping a pilot, or reviewing the security model? Tell us about your environment and we'll take it from there.
Your message goes directly to the team that builds Codeflare. Expect a reply within 1 to 2 business days. Submissions are protected against bots and are not stored. Your data is never sold or shared.