Human judgment. Agent speed.
One governed test-data world.
Humans and coding agents work on the same DATAMIMIC project. The human decides intent and resolves ambiguity. The agent can inspect project context, connected environments and schemas, then author and verify models. DATAMIMIC keeps execution deterministic and governed.
Human · Intent
Decide what should be true.
Business meaning, ambiguity, trade-offs and acceptance stay visible to the engineer.
Agent · Author
Do the context-heavy work.
Inspect, model, repair, validate and iterate without inventing a separate engineering world.
Platform · Verify
Keep the result bounded.
Permissions, locks, deterministic execution, task evidence and audit remain platform-owned.
Human + Coding Agent
Humans and coding agents work on the same DATAMIMIC project. The human decides intent and resolves ambiguity.
Keep intent close to the engineer.
The IDE opens the same project files as the web UI and signs in through the platform. Language-server support helps while you edit, but the model stays explicit and reviewable. The engineer can see the assumptions instead of hiding them inside generation code. The extension ships with the Platform deployment, so there is no marketplace install and no local clone of the project.
Model intent stays visible
Relationships, constraints and generators are reviewable.
Same runtime contract
Authoring and execution validate against the same model surface.
Project-aware references
Resolve source and target clients from the project.
Multi-file project context
Work across model files without a second local truth.
Language-server guidance
Completion for expressions, model sources and references while you work.
Give the agent context, not a shortcut.
The agent works through DATAMIMIC instead of creating a private test-data path beside the project. It can inspect the context offered to the project, author a model, get structured diagnostics and verify the result before real execution.
Governed MCP access
OAuth or project access token, scoped to the project.
Project context
Reads and edits project files and scans the environments made available to the project.
Schemas and relationships
Uses observed structure instead of inventing it from the implementation.
Model from intent
Turns requirements into an explicit DATAMIMIC model.
Structured verification
Lint with a rule id and fix hint on every finding, plus a capped dry-run before the verified model is written back to the DATAMIMIC project.
The implementation should not define the world that proves it correct.
Agents can write code, fixtures and tests. That is useful. The risk starts when all three carry the same wrong interpretation and still agree with each other.
Independent test world
Spec
Schema
Domain constraints
Observed environment
Explicit test-data model
Relationships · cardinalities · ranges · generators · expectations
Challenges the implementation from outside
Independent does not mean automatically correct. It removes one dangerous feedback loop.
Implementation-defines-world
Implementation
Fixtures
Expectations
Tests green
Self-consistent can still be wrong
The same assumption can move through every artifact without anything disagreeing.
Keep agentic work inside the governed platform.
The web UI, IDE and coding agent are clients of the same DATAMIMIC Platform. The agent does not get a parallel control plane. It works inside the same project boundaries, identity and permissions, file locks and task evidence as the human. The team owns the project and decides what is accepted and executed.
Agentic does not need a second control plane. Keep the agent inside the project, permissions and audit path the organization already owns.
What the agent cannot do
Bypass permissions
Agent access stays inside the user or project scope granted by the platform.
Ignore file locks
Web UI, IDE, and agent share the same file-lock contract. Active locks prevent silent overwrites, but any client can see who holds the lock and explicitly take it over.
Work off the record
Agent work goes through the same server-owned task and evidence path. It does not disappear into a separate AI execution history.
DATAMIMIC CE makes the test world explicit. The Platform connects it to real enterprise context.
CE is the deterministic engine and authoring contract. The Platform adds the environment and operational controls around it.
DATAMIMIC CE
Model and verify the data world.
Open-source, model-driven test-data generation for local, CI and agent workflows.
- Machine-readable capabilities and references
- Explicit model intent and expectations
- Structured validation and bounded verification
- Deterministic generation and replay
- Optional MCP adapter: reference, scaffold, lint and bounded dry-run. No Platform required
DATAMIMIC Platform
Connect the model to the real project world.
Environment analysis and governance for teams working across real systems.
- Connected SQL, MongoDB, Kafka and RabbitMQ environments
- Schema and relationship analysis
- Generator and converter recommendations
- Permissions, locks, audit and multi-system execution
- Hosted MCP server and Authoring API, scoped to the project
Frequently Asked Questions.
How does a coding agent check a model before real execution?
Through the authoring contract. The agent can query the canonical reference, scaffold a model from intent, lint it with structured diagnostics, and run a bounded dry-run before real execution is requested.
Which IDEs and coding agents can use the DATAMIMIC workflow?
Do the human and agent work on separate project copies?
No. They work against the same platform project and the same file, environment and lock contracts. That avoids creating an AI-only project reality beside the normal engineering workflow.
Does deterministic mean the test world is correct?
No. Determinism means the same controlled inputs reproduce the same result across the runtime combinations we continuously test. Outside that tested matrix, the same claim needs new evidence. A wrong spec or wrong expectation can still create a deterministic wrong world. This is why DATAMIMIC keeps the model and its assumptions explicit and reviewable.
Do I need the DATAMIMIC Platform to use a coding agent?
No. DATAMIMIC CE is MIT-licensed and can expose its authoring service through an optional MCP adapter. An agent can query the reference, scaffold a model, lint it and run a bounded dry-run locally or in CI. The Platform adds connected enterprise environments, schema and relationship analysis, permissions, file locks, audit evidence and multi-system execution.
How does DATAMIMIC work with AI coding agents?
Through MCP, on two levels. DATAMIMIC CE can expose its canonical authoring service through an optional MCP adapter: reference, scaffold, lint and bounded dry-run. The Platform adds a hosted MCP server and Authoring API: the agent signs in with OAuth or a project access token, reads and edits the project and its connected environments, and builds a model from a natural-language request. Verification happens before real execution, and the result is still an explicit, reviewable DATAMIMIC model, not a black box.
Want to see humans and agents working on the same project?
See how engineers and coding agents work in the same DATAMIMIC project. The human sets intent and reviews the model; the agent explores project context, authors test data models, and verifies results within the same permissions, locks, and audit trail.